751 lines
25 KiB
C++
751 lines
25 KiB
C++
#include "XCUIAssetDocumentSource.h"
|
|
|
|
#include <XCEngine/Core/Asset/ResourceHandle.h>
|
|
#include <XCEngine/Core/Asset/ResourceManager.h>
|
|
#include <XCEngine/Core/Containers/String.h>
|
|
#include <XCEngine/Resources/UI/UIDocuments.h>
|
|
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
#include <optional>
|
|
#include <type_traits>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
|
|
namespace XCEngine {
|
|
namespace Editor {
|
|
namespace XCUIBackend {
|
|
|
|
namespace fs = std::filesystem;
|
|
|
|
namespace {
|
|
|
|
using XCEngine::Containers::String;
|
|
using XCEngine::Resources::CompileUIDocument;
|
|
using XCEngine::Resources::ResourceManager;
|
|
using XCEngine::Resources::UIDocumentCompileRequest;
|
|
using XCEngine::Resources::UIDocumentCompileResult;
|
|
using XCEngine::Resources::UIDocumentKind;
|
|
using XCEngine::Resources::UIDocumentResource;
|
|
using XCEngine::Resources::UITheme;
|
|
using XCEngine::Resources::UIView;
|
|
|
|
String ToContainersString(const std::string& value) {
|
|
return String(value.c_str());
|
|
}
|
|
|
|
std::string ToStdString(const String& value) {
|
|
return std::string(value.CStr());
|
|
}
|
|
|
|
std::string ToGenericString(const fs::path& path) {
|
|
return path.lexically_normal().generic_string();
|
|
}
|
|
|
|
bool PathExists(const fs::path& path) {
|
|
std::error_code ec;
|
|
return !path.empty() && fs::exists(path, ec) && !fs::is_directory(path, ec);
|
|
}
|
|
|
|
bool TryGetWriteTime(
|
|
const fs::path& path,
|
|
fs::file_time_type& outWriteTime) {
|
|
std::error_code ec;
|
|
if (path.empty() || !fs::exists(path, ec) || fs::is_directory(path, ec)) {
|
|
return false;
|
|
}
|
|
|
|
outWriteTime = fs::last_write_time(path, ec);
|
|
return !ec;
|
|
}
|
|
|
|
std::string SanitizeSetName(const std::string& setName) {
|
|
std::string sanitized = {};
|
|
sanitized.reserve(setName.size());
|
|
for (unsigned char ch : setName) {
|
|
if (std::isalnum(ch) != 0 || ch == '_' || ch == '-') {
|
|
sanitized.push_back(static_cast<char>(ch));
|
|
}
|
|
}
|
|
|
|
return sanitized.empty() ? std::string("Default") : sanitized;
|
|
}
|
|
|
|
std::string ToSnakeCase(const std::string& value) {
|
|
std::string snake = {};
|
|
snake.reserve(value.size() + 8u);
|
|
|
|
char previous = '\0';
|
|
for (unsigned char rawCh : value) {
|
|
if (!(std::isalnum(rawCh) != 0)) {
|
|
if (!snake.empty() && snake.back() != '_') {
|
|
snake.push_back('_');
|
|
}
|
|
previous = '_';
|
|
continue;
|
|
}
|
|
|
|
const char ch = static_cast<char>(rawCh);
|
|
const bool isUpper = std::isupper(rawCh) != 0;
|
|
const bool previousIsLowerOrDigit =
|
|
std::islower(static_cast<unsigned char>(previous)) != 0 ||
|
|
std::isdigit(static_cast<unsigned char>(previous)) != 0;
|
|
if (isUpper && !snake.empty() && previousIsLowerOrDigit && snake.back() != '_') {
|
|
snake.push_back('_');
|
|
}
|
|
|
|
snake.push_back(static_cast<char>(std::tolower(rawCh)));
|
|
previous = ch;
|
|
}
|
|
|
|
while (!snake.empty() && snake.back() == '_') {
|
|
snake.pop_back();
|
|
}
|
|
|
|
return snake.empty() ? std::string("default") : snake;
|
|
}
|
|
|
|
std::optional<fs::path> GetCurrentPath() {
|
|
std::error_code ec;
|
|
const fs::path currentPath = fs::current_path(ec);
|
|
if (ec) {
|
|
return std::nullopt;
|
|
}
|
|
return currentPath;
|
|
}
|
|
|
|
fs::path GetConfiguredResourceRoot() {
|
|
const String resourceRoot = ResourceManager::Get().GetResourceRoot();
|
|
if (resourceRoot.Empty()) {
|
|
return fs::path();
|
|
}
|
|
|
|
return fs::path(resourceRoot.CStr()).lexically_normal();
|
|
}
|
|
|
|
std::optional<std::string> FindKnownDocumentUnderRoot(
|
|
const fs::path& root,
|
|
const XCUIAssetDocumentSource::PathSet& paths) {
|
|
if (PathExists(root / paths.view.primaryRelativePath)) {
|
|
return paths.view.primaryRelativePath;
|
|
}
|
|
if (PathExists(root / paths.theme.primaryRelativePath)) {
|
|
return paths.theme.primaryRelativePath;
|
|
}
|
|
if (PathExists(root / paths.view.legacyRelativePath)) {
|
|
return paths.view.legacyRelativePath;
|
|
}
|
|
if (PathExists(root / paths.theme.legacyRelativePath)) {
|
|
return paths.theme.legacyRelativePath;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
void AppendUniqueSearchRoot(
|
|
const fs::path& searchRoot,
|
|
std::vector<fs::path>& outRoots,
|
|
std::unordered_set<std::string>& seenRoots) {
|
|
if (searchRoot.empty()) {
|
|
return;
|
|
}
|
|
|
|
const fs::path normalized = searchRoot.lexically_normal();
|
|
const std::string key = ToGenericString(normalized);
|
|
if (!seenRoots.insert(key).second) {
|
|
return;
|
|
}
|
|
|
|
outRoots.push_back(normalized);
|
|
}
|
|
|
|
std::vector<fs::path> BuildRepositoryRootSearchRoots(
|
|
const std::vector<fs::path>& explicitSearchRoots,
|
|
bool includeDefaultSearchRoots) {
|
|
std::vector<fs::path> searchRoots = {};
|
|
std::unordered_set<std::string> seenRoots = {};
|
|
|
|
for (const fs::path& explicitSearchRoot : explicitSearchRoots) {
|
|
AppendUniqueSearchRoot(explicitSearchRoot, searchRoots, seenRoots);
|
|
}
|
|
|
|
if (!includeDefaultSearchRoots) {
|
|
return searchRoots;
|
|
}
|
|
|
|
#ifdef XCENGINE_NEW_EDITOR_REPO_ROOT
|
|
AppendUniqueSearchRoot(
|
|
fs::path(XCENGINE_NEW_EDITOR_REPO_ROOT),
|
|
searchRoots,
|
|
seenRoots);
|
|
#endif
|
|
|
|
const fs::path resourceRoot = GetConfiguredResourceRoot();
|
|
if (!resourceRoot.empty()) {
|
|
AppendUniqueSearchRoot(resourceRoot, searchRoots, seenRoots);
|
|
}
|
|
|
|
const std::optional<fs::path> currentPath = GetCurrentPath();
|
|
if (currentPath.has_value()) {
|
|
AppendUniqueSearchRoot(*currentPath, searchRoots, seenRoots);
|
|
}
|
|
|
|
return searchRoots;
|
|
}
|
|
|
|
void AddCandidate(
|
|
std::vector<XCUIAssetDocumentSource::ResolutionCandidate>& candidates,
|
|
std::unordered_set<std::string>& seenPaths,
|
|
const std::string& requestPath,
|
|
const fs::path& resolvedPath,
|
|
XCUIAssetDocumentSource::PathOrigin origin) {
|
|
const std::string key = ToGenericString(resolvedPath);
|
|
if (requestPath.empty() || resolvedPath.empty() || !seenPaths.insert(key).second) {
|
|
return;
|
|
}
|
|
|
|
XCUIAssetDocumentSource::ResolutionCandidate candidate = {};
|
|
candidate.requestPath = requestPath;
|
|
candidate.resolvedPath = resolvedPath.lexically_normal();
|
|
candidate.origin = origin;
|
|
candidates.push_back(std::move(candidate));
|
|
}
|
|
|
|
void AddRelativeCandidateIfReachable(
|
|
const std::string& relativePath,
|
|
const fs::path& repositoryRoot,
|
|
const fs::path& resourceRoot,
|
|
XCUIAssetDocumentSource::PathOrigin origin,
|
|
std::vector<XCUIAssetDocumentSource::ResolutionCandidate>& candidates,
|
|
std::unordered_set<std::string>& seenPaths) {
|
|
if (relativePath.empty()) {
|
|
return;
|
|
}
|
|
|
|
const fs::path relative(relativePath);
|
|
if (PathExists(relative)) {
|
|
AddCandidate(candidates, seenPaths, relativePath, relative, origin);
|
|
return;
|
|
}
|
|
|
|
if (!resourceRoot.empty() && PathExists(resourceRoot / relative)) {
|
|
AddCandidate(candidates, seenPaths, relativePath, resourceRoot / relative, origin);
|
|
return;
|
|
}
|
|
|
|
if (!repositoryRoot.empty() && PathExists(repositoryRoot / relative)) {
|
|
AddCandidate(
|
|
candidates,
|
|
seenPaths,
|
|
(repositoryRoot / relative).generic_string(),
|
|
repositoryRoot / relative,
|
|
origin);
|
|
}
|
|
}
|
|
|
|
template <typename TDocumentResource>
|
|
bool TryLoadDocumentFromResourceManager(
|
|
const std::string& requestPath,
|
|
UIDocumentCompileResult& outResult) {
|
|
static_assert(
|
|
std::is_base_of_v<UIDocumentResource, TDocumentResource>,
|
|
"TDocumentResource must derive from UIDocumentResource");
|
|
|
|
auto resource = ResourceManager::Get().Load<TDocumentResource>(ToContainersString(requestPath));
|
|
if (!resource || resource->GetDocument().valid == false) {
|
|
return false;
|
|
}
|
|
|
|
outResult = UIDocumentCompileResult();
|
|
outResult.document = resource->GetDocument();
|
|
outResult.succeeded = outResult.document.valid;
|
|
return outResult.succeeded;
|
|
}
|
|
|
|
bool TryLoadDocumentFromResourceManager(
|
|
UIDocumentKind kind,
|
|
const std::string& requestPath,
|
|
UIDocumentCompileResult& outResult) {
|
|
switch (kind) {
|
|
case UIDocumentKind::View:
|
|
return TryLoadDocumentFromResourceManager<UIView>(requestPath, outResult);
|
|
case UIDocumentKind::Theme:
|
|
return TryLoadDocumentFromResourceManager<UITheme>(requestPath, outResult);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool TryCompileDocumentDirect(
|
|
const XCUIAssetDocumentSource::DocumentPathSpec& spec,
|
|
const std::string& requestPath,
|
|
UIDocumentCompileResult& outResult) {
|
|
UIDocumentCompileRequest request = {};
|
|
request.kind = spec.kind;
|
|
request.path = ToContainersString(requestPath);
|
|
request.expectedRootTag = ToContainersString(spec.expectedRootTag);
|
|
return CompileUIDocument(request, outResult) && outResult.succeeded;
|
|
}
|
|
|
|
void CollectTrackedSourcePaths(
|
|
const XCUIAssetDocumentSource::DocumentLoadState& documentState,
|
|
std::vector<std::string>& outPaths,
|
|
std::unordered_set<std::string>& seenPaths) {
|
|
if (!documentState.succeeded) {
|
|
return;
|
|
}
|
|
|
|
auto pushPath = [&](const String& path) {
|
|
if (path.Empty()) {
|
|
return;
|
|
}
|
|
|
|
const std::string text = ToStdString(path);
|
|
if (seenPaths.insert(text).second) {
|
|
outPaths.push_back(text);
|
|
}
|
|
};
|
|
|
|
if (!documentState.sourcePath.empty() &&
|
|
seenPaths.insert(documentState.sourcePath).second) {
|
|
outPaths.push_back(documentState.sourcePath);
|
|
}
|
|
|
|
if (!documentState.compileResult.document.valid) {
|
|
return;
|
|
}
|
|
|
|
pushPath(documentState.compileResult.document.sourcePath);
|
|
for (const String& dependency : documentState.compileResult.document.dependencies) {
|
|
pushPath(dependency);
|
|
}
|
|
}
|
|
|
|
void UpdateTrackedWriteTimes(
|
|
const XCUIAssetDocumentSource::LoadState& state,
|
|
std::vector<XCUIAssetDocumentSource::TrackedWriteTime>& outTrackedWriteTimes,
|
|
std::vector<std::string>& outMissingTrackedSourcePaths,
|
|
bool& outChangeTrackingReady,
|
|
std::string& outTrackingStatusMessage) {
|
|
outTrackedWriteTimes.clear();
|
|
outMissingTrackedSourcePaths.clear();
|
|
outTrackedWriteTimes.reserve(state.trackedSourcePaths.size());
|
|
outMissingTrackedSourcePaths.reserve(state.trackedSourcePaths.size());
|
|
|
|
for (const std::string& pathText : state.trackedSourcePaths) {
|
|
XCUIAssetDocumentSource::TrackedWriteTime tracked = {};
|
|
tracked.path = fs::path(pathText).lexically_normal();
|
|
if (!TryGetWriteTime(tracked.path, tracked.writeTime)) {
|
|
outMissingTrackedSourcePaths.push_back(ToGenericString(tracked.path));
|
|
continue;
|
|
}
|
|
|
|
outTrackedWriteTimes.push_back(std::move(tracked));
|
|
}
|
|
|
|
outChangeTrackingReady =
|
|
!state.trackedSourcePaths.empty() &&
|
|
outTrackedWriteTimes.size() == state.trackedSourcePaths.size();
|
|
|
|
if (state.trackedSourcePaths.empty()) {
|
|
outTrackingStatusMessage = "No XCUI source files were recorded for hot reload.";
|
|
return;
|
|
}
|
|
|
|
if (outMissingTrackedSourcePaths.empty()) {
|
|
outTrackingStatusMessage =
|
|
"Tracking " +
|
|
std::to_string(static_cast<unsigned long long>(outTrackedWriteTimes.size())) +
|
|
" XCUI source file(s) for hot reload.";
|
|
return;
|
|
}
|
|
|
|
outTrackingStatusMessage =
|
|
"Tracking " +
|
|
std::to_string(static_cast<unsigned long long>(outTrackedWriteTimes.size())) +
|
|
" of " +
|
|
std::to_string(static_cast<unsigned long long>(state.trackedSourcePaths.size())) +
|
|
" XCUI source file(s); unable to stat " +
|
|
std::to_string(static_cast<unsigned long long>(outMissingTrackedSourcePaths.size())) +
|
|
" path(s).";
|
|
}
|
|
|
|
XCUIAssetDocumentSource::DocumentLoadState LoadDocument(
|
|
const XCUIAssetDocumentSource::DocumentPathSpec& spec,
|
|
const fs::path& repositoryRoot,
|
|
bool preferCompilerFallback) {
|
|
XCUIAssetDocumentSource::DocumentLoadState state = {};
|
|
state.kind = spec.kind;
|
|
state.expectedRootTag = spec.expectedRootTag;
|
|
state.primaryRelativePath = spec.primaryRelativePath;
|
|
state.legacyRelativePath = spec.legacyRelativePath;
|
|
|
|
state.candidatePaths = XCUIAssetDocumentSource::CollectCandidatePaths(
|
|
spec,
|
|
repositoryRoot,
|
|
GetConfiguredResourceRoot());
|
|
if (state.candidatePaths.empty()) {
|
|
state.errorMessage =
|
|
"Unable to locate XCUI document source. Expected " +
|
|
spec.primaryRelativePath +
|
|
" or legacy mirror " +
|
|
spec.legacyRelativePath + ".";
|
|
return state;
|
|
}
|
|
|
|
state.attemptMessages.reserve(state.candidatePaths.size());
|
|
|
|
for (const XCUIAssetDocumentSource::ResolutionCandidate& candidate : state.candidatePaths) {
|
|
state.requestedPath = candidate.requestPath;
|
|
state.resolvedPath = candidate.resolvedPath;
|
|
state.pathOrigin = candidate.origin;
|
|
state.usedLegacyFallback =
|
|
candidate.origin == XCUIAssetDocumentSource::PathOrigin::LegacyMirror;
|
|
|
|
UIDocumentCompileResult compileResult = {};
|
|
if (TryCompileDocumentDirect(spec, candidate.requestPath, compileResult)) {
|
|
state.backend = XCUIAssetDocumentSource::LoadBackend::CompilerFallback;
|
|
state.compileResult = std::move(compileResult);
|
|
state.sourcePath = ToStdString(state.compileResult.document.sourcePath);
|
|
if (state.sourcePath.empty()) {
|
|
state.sourcePath = ToGenericString(candidate.resolvedPath);
|
|
}
|
|
state.statusMessage =
|
|
(preferCompilerFallback
|
|
? std::string("Tracked source changed; direct compile refresh succeeded from ")
|
|
: std::string("Direct compile load succeeded from ")) +
|
|
ToGenericString(candidate.resolvedPath) +
|
|
".";
|
|
state.succeeded = true;
|
|
return state;
|
|
}
|
|
|
|
UIDocumentCompileResult resourceResult = {};
|
|
if (TryLoadDocumentFromResourceManager(spec.kind, candidate.requestPath, resourceResult)) {
|
|
state.backend = XCUIAssetDocumentSource::LoadBackend::ResourceManager;
|
|
state.compileResult = std::move(resourceResult);
|
|
state.sourcePath = ToStdString(state.compileResult.document.sourcePath);
|
|
if (state.sourcePath.empty()) {
|
|
state.sourcePath = ToGenericString(candidate.resolvedPath);
|
|
}
|
|
state.statusMessage =
|
|
std::string("Loaded via ResourceManager from ") +
|
|
ToString(candidate.origin) +
|
|
" path: " +
|
|
ToGenericString(candidate.resolvedPath) +
|
|
".";
|
|
state.succeeded = true;
|
|
return state;
|
|
}
|
|
|
|
const std::string compileError = compileResult.errorMessage.Empty()
|
|
? std::string("ResourceManager load failed and compile fallback returned no diagnostic.")
|
|
: ToStdString(compileResult.errorMessage);
|
|
state.attemptMessages.push_back(
|
|
std::string(ToString(candidate.origin)) +
|
|
" candidate " +
|
|
ToGenericString(candidate.resolvedPath) +
|
|
" -> " +
|
|
compileError);
|
|
}
|
|
|
|
state.requestedPath.clear();
|
|
state.resolvedPath.clear();
|
|
state.sourcePath.clear();
|
|
state.backend = XCUIAssetDocumentSource::LoadBackend::None;
|
|
state.pathOrigin = XCUIAssetDocumentSource::PathOrigin::None;
|
|
state.usedLegacyFallback = false;
|
|
|
|
state.errorMessage = state.attemptMessages.empty()
|
|
? std::string("Failed to load XCUI document.")
|
|
: state.attemptMessages.front();
|
|
if (state.attemptMessages.size() > 1u) {
|
|
state.errorMessage += " (";
|
|
state.errorMessage += std::to_string(
|
|
static_cast<unsigned long long>(state.attemptMessages.size()));
|
|
state.errorMessage += " candidates tried)";
|
|
}
|
|
return state;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
const char* ToString(XCUIAssetDocumentSource::PathOrigin origin) {
|
|
switch (origin) {
|
|
case XCUIAssetDocumentSource::PathOrigin::ProjectAssets:
|
|
return "project-assets";
|
|
case XCUIAssetDocumentSource::PathOrigin::LegacyMirror:
|
|
return "legacy-mirror";
|
|
default:
|
|
return "none";
|
|
}
|
|
}
|
|
|
|
const char* ToString(XCUIAssetDocumentSource::LoadBackend backend) {
|
|
switch (backend) {
|
|
case XCUIAssetDocumentSource::LoadBackend::ResourceManager:
|
|
return "resource-manager";
|
|
case XCUIAssetDocumentSource::LoadBackend::CompilerFallback:
|
|
return "compiler-fallback";
|
|
default:
|
|
return "none";
|
|
}
|
|
}
|
|
|
|
XCUIAssetDocumentSource::XCUIAssetDocumentSource() = default;
|
|
|
|
XCUIAssetDocumentSource::XCUIAssetDocumentSource(PathSet paths)
|
|
: m_paths(std::move(paths)) {
|
|
}
|
|
|
|
void XCUIAssetDocumentSource::SetPathSet(PathSet paths) {
|
|
m_paths = std::move(paths);
|
|
}
|
|
|
|
const XCUIAssetDocumentSource::PathSet& XCUIAssetDocumentSource::GetPathSet() const {
|
|
return m_paths;
|
|
}
|
|
|
|
bool XCUIAssetDocumentSource::Reload() {
|
|
const bool preferCompilerFallback = m_state.succeeded && HasTrackedChanges();
|
|
m_state = LoadState();
|
|
m_state.paths = m_paths;
|
|
|
|
m_state.repositoryDiscovery = DiagnoseRepositoryRoot(m_paths);
|
|
m_state.repositoryRoot = m_state.repositoryDiscovery.repositoryRoot;
|
|
|
|
m_state.view = LoadDocument(m_paths.view, m_state.repositoryRoot, preferCompilerFallback);
|
|
if (!m_state.view.succeeded) {
|
|
m_state.errorMessage = m_state.view.errorMessage;
|
|
if (!m_state.repositoryDiscovery.statusMessage.empty()) {
|
|
m_state.errorMessage += " " + m_state.repositoryDiscovery.statusMessage;
|
|
}
|
|
m_state.statusMessage =
|
|
"XCUI view document load failed. " +
|
|
m_state.repositoryDiscovery.statusMessage;
|
|
m_trackedWriteTimes.clear();
|
|
return false;
|
|
}
|
|
|
|
m_state.theme = LoadDocument(m_paths.theme, m_state.repositoryRoot, preferCompilerFallback);
|
|
if (!m_state.theme.succeeded) {
|
|
m_state.errorMessage = m_state.theme.errorMessage;
|
|
if (!m_state.repositoryDiscovery.statusMessage.empty()) {
|
|
m_state.errorMessage += " " + m_state.repositoryDiscovery.statusMessage;
|
|
}
|
|
m_state.statusMessage =
|
|
"XCUI theme document load failed. " +
|
|
m_state.repositoryDiscovery.statusMessage;
|
|
m_trackedWriteTimes.clear();
|
|
return false;
|
|
}
|
|
|
|
std::unordered_set<std::string> seenPaths = {};
|
|
CollectTrackedSourcePaths(m_state.view, m_state.trackedSourcePaths, seenPaths);
|
|
CollectTrackedSourcePaths(m_state.theme, m_state.trackedSourcePaths, seenPaths);
|
|
UpdateTrackedWriteTimes(
|
|
m_state,
|
|
m_trackedWriteTimes,
|
|
m_state.missingTrackedSourcePaths,
|
|
m_state.changeTrackingReady,
|
|
m_state.trackingStatusMessage);
|
|
|
|
m_state.usedLegacyFallback =
|
|
m_state.view.usedLegacyFallback || m_state.theme.usedLegacyFallback;
|
|
m_state.succeeded = true;
|
|
m_state.statusMessage =
|
|
(m_state.usedLegacyFallback
|
|
? std::string("XCUI documents loaded with legacy mirror fallback. ")
|
|
: std::string("XCUI documents loaded from Assets/XCUI/NewEditor. ")) +
|
|
m_state.trackingStatusMessage;
|
|
return true;
|
|
}
|
|
|
|
bool XCUIAssetDocumentSource::ReloadIfChanged() {
|
|
if (!m_state.succeeded) {
|
|
return Reload();
|
|
}
|
|
|
|
return HasTrackedChanges() ? Reload() : true;
|
|
}
|
|
|
|
bool XCUIAssetDocumentSource::HasTrackedChanges() const {
|
|
if (!m_state.succeeded) {
|
|
return true;
|
|
}
|
|
|
|
if (m_state.trackedSourcePaths.empty()) {
|
|
return false;
|
|
}
|
|
|
|
if (m_trackedWriteTimes.size() != m_state.trackedSourcePaths.size()) {
|
|
return true;
|
|
}
|
|
|
|
for (const TrackedWriteTime& tracked : m_trackedWriteTimes) {
|
|
fs::file_time_type currentWriteTime = {};
|
|
if (!TryGetWriteTime(tracked.path, currentWriteTime) ||
|
|
currentWriteTime != tracked.writeTime) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool XCUIAssetDocumentSource::IsLoaded() const {
|
|
return m_state.succeeded;
|
|
}
|
|
|
|
const XCUIAssetDocumentSource::LoadState& XCUIAssetDocumentSource::GetState() const {
|
|
return m_state;
|
|
}
|
|
|
|
XCUIAssetDocumentSource::PathSet XCUIAssetDocumentSource::MakePathSet(
|
|
const std::string& setName) {
|
|
PathSet paths = {};
|
|
paths.setName = SanitizeSetName(setName);
|
|
|
|
paths.view.kind = UIDocumentKind::View;
|
|
paths.view.expectedRootTag = "View";
|
|
paths.view.primaryRelativePath = BuildProjectAssetViewPath(paths.setName);
|
|
paths.view.legacyRelativePath = BuildLegacyViewPath(paths.setName);
|
|
|
|
paths.theme.kind = UIDocumentKind::Theme;
|
|
paths.theme.expectedRootTag = "Theme";
|
|
paths.theme.primaryRelativePath = BuildProjectAssetThemePath(paths.setName);
|
|
paths.theme.legacyRelativePath = BuildLegacyThemePath(paths.setName);
|
|
return paths;
|
|
}
|
|
|
|
XCUIAssetDocumentSource::PathSet XCUIAssetDocumentSource::MakeDemoPathSet() {
|
|
return MakePathSet("Demo");
|
|
}
|
|
|
|
XCUIAssetDocumentSource::PathSet XCUIAssetDocumentSource::MakeLayoutLabPathSet() {
|
|
return MakePathSet("LayoutLab");
|
|
}
|
|
|
|
std::vector<XCUIAssetDocumentSource::ResolutionCandidate>
|
|
XCUIAssetDocumentSource::CollectCandidatePaths(
|
|
const DocumentPathSpec& spec,
|
|
const fs::path& repositoryRoot) {
|
|
return CollectCandidatePaths(spec, repositoryRoot, GetConfiguredResourceRoot());
|
|
}
|
|
|
|
std::vector<XCUIAssetDocumentSource::ResolutionCandidate>
|
|
XCUIAssetDocumentSource::CollectCandidatePaths(
|
|
const DocumentPathSpec& spec,
|
|
const fs::path& repositoryRoot,
|
|
const fs::path& resourceRoot) {
|
|
std::vector<ResolutionCandidate> candidates = {};
|
|
std::unordered_set<std::string> seenPaths = {};
|
|
|
|
AddRelativeCandidateIfReachable(
|
|
spec.primaryRelativePath,
|
|
repositoryRoot,
|
|
resourceRoot,
|
|
PathOrigin::ProjectAssets,
|
|
candidates,
|
|
seenPaths);
|
|
AddRelativeCandidateIfReachable(
|
|
spec.legacyRelativePath,
|
|
repositoryRoot,
|
|
resourceRoot,
|
|
PathOrigin::LegacyMirror,
|
|
candidates,
|
|
seenPaths);
|
|
return candidates;
|
|
}
|
|
|
|
XCUIAssetDocumentSource::RepositoryDiscovery
|
|
XCUIAssetDocumentSource::DiagnoseRepositoryRoot(const PathSet& paths) {
|
|
return DiagnoseRepositoryRoot(paths, {}, true);
|
|
}
|
|
|
|
XCUIAssetDocumentSource::RepositoryDiscovery
|
|
XCUIAssetDocumentSource::DiagnoseRepositoryRoot(
|
|
const PathSet& paths,
|
|
const std::vector<fs::path>& searchRoots,
|
|
bool includeDefaultSearchRoots) {
|
|
RepositoryDiscovery discovery = {};
|
|
discovery.probes.reserve(searchRoots.size() + 3u);
|
|
|
|
const std::vector<fs::path> effectiveSearchRoots = BuildRepositoryRootSearchRoots(
|
|
searchRoots,
|
|
includeDefaultSearchRoots);
|
|
discovery.probes.reserve(effectiveSearchRoots.size());
|
|
|
|
for (const fs::path& searchRoot : effectiveSearchRoots) {
|
|
RepositoryProbe probe = {};
|
|
probe.searchRoot = searchRoot;
|
|
|
|
fs::path current = searchRoot;
|
|
while (!current.empty()) {
|
|
const std::optional<std::string> matchedRelativePath =
|
|
FindKnownDocumentUnderRoot(current, paths);
|
|
if (matchedRelativePath.has_value()) {
|
|
probe.matched = true;
|
|
probe.matchedRoot = current.lexically_normal();
|
|
probe.matchedRelativePath = *matchedRelativePath;
|
|
discovery.repositoryRoot = probe.matchedRoot;
|
|
discovery.probes.push_back(std::move(probe));
|
|
discovery.statusMessage =
|
|
"Repository root resolved to " +
|
|
ToGenericString(discovery.repositoryRoot) +
|
|
" via " +
|
|
discovery.probes.back().matchedRelativePath +
|
|
".";
|
|
return discovery;
|
|
}
|
|
|
|
const fs::path parent = current.parent_path();
|
|
if (parent == current) {
|
|
break;
|
|
}
|
|
current = parent;
|
|
}
|
|
|
|
discovery.probes.push_back(std::move(probe));
|
|
}
|
|
|
|
discovery.statusMessage =
|
|
"Repository root not found for XCUI set '" +
|
|
paths.setName +
|
|
"'. Probed " +
|
|
std::to_string(static_cast<unsigned long long>(discovery.probes.size())) +
|
|
" search root(s).";
|
|
return discovery;
|
|
}
|
|
|
|
std::string XCUIAssetDocumentSource::BuildProjectAssetViewPath(
|
|
const std::string& setName) {
|
|
const std::string folderName = SanitizeSetName(setName);
|
|
return std::string(kProjectAssetRoot) + "/" + folderName + "/View.xcui";
|
|
}
|
|
|
|
std::string XCUIAssetDocumentSource::BuildProjectAssetThemePath(
|
|
const std::string& setName) {
|
|
const std::string folderName = SanitizeSetName(setName);
|
|
return std::string(kProjectAssetRoot) + "/" + folderName + "/Theme.xctheme";
|
|
}
|
|
|
|
std::string XCUIAssetDocumentSource::BuildLegacyViewPath(
|
|
const std::string& setName) {
|
|
return std::string(kLegacyResourceRoot) +
|
|
"/xcui_" +
|
|
ToSnakeCase(SanitizeSetName(setName)) +
|
|
"_view.xcui";
|
|
}
|
|
|
|
std::string XCUIAssetDocumentSource::BuildLegacyThemePath(
|
|
const std::string& setName) {
|
|
return std::string(kLegacyResourceRoot) +
|
|
"/xcui_" +
|
|
ToSnakeCase(SanitizeSetName(setName)) +
|
|
"_theme.xctheme";
|
|
}
|
|
|
|
} // namespace XCUIBackend
|
|
} // namespace Editor
|
|
} // namespace XCEngine
|