system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-22 02:26:11 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

LibFileSystem+Userland: Return ByteString from real_path()

Browse source
This commit is contained in:
Sam Atkins 2024-01-15 16:23:24 +00:00 committed by Sam Atkins
parent cdf17efb9a
commit 56c5ffe398
25 changed files with 44 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Userland/Applications/FileManager/DirectoryView.cpp
View file

@ -413,11 +413,11 @@ bool DirectoryView::open(ByteString const& path)
warnln("Failed to open '{}': {}", real_path, result.error());
}
if (model().root_path() == real_path.to_byte_string()) {
if (model().root_path() == real_path) {
refresh();
} else {
set_active_widget(&current_view());
model().set_root_path(real_path.to_byte_string());
model().set_root_path(real_path);
}
return true;
}

2
Userland/Applications/FileManager/main.cpp
View file

@ -109,7 +109,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
LexicalPath path(initial_location);
if (!initial_location.is_empty()) {
if (auto error_or_path = FileSystem::real_path(initial_location); !ignore_path_resolution && !error_or_path.is_error())
initial_location = error_or_path.release_value().to_byte_string();
initial_location = error_or_path.release_value();
if (!FileSystem::is_directory(initial_location)) {
// We want to extract zips to a temporary directory when FileManager is launched with a .zip file as its first argument

2
Userland/Applications/Run/RunWindow.cpp
View file

@ -147,7 +147,7 @@ bool RunWindow::run_via_launch(ByteString const& run_input)
warnln("Failed to launch '{}': {}", file_path, real_path_or_error.error());
return false;
}
url = URL::create_with_url_or_path(real_path_or_error.release_value().to_byte_string());
url = URL::create_with_url_or_path(real_path_or_error.release_value());
}
if (!Desktop::Launcher::open(url)) {

2
Userland/DevTools/HackStudio/main.cpp
View file

@ -228,7 +228,7 @@ static ErrorOr<NonnullRefPtr<HackStudioWidget>> create_hack_studio_widget(bool m
else if (auto last_path = last_opened_project_path(); last_path.has_value())
project_path = last_path.release_value();
else
project_path = TRY(FileSystem::real_path("."sv)).to_byte_string();
project_path = TRY(FileSystem::real_path("."sv));
return HackStudioWidget::create(project_path);
}

12
Userland/Libraries/LibFileSystem/FileSystem.cpp
View file

@ -31,7 +31,7 @@ ErrorOr<ByteString> current_working_directory()
ErrorOr<ByteString> absolute_path(StringView path)
{
if (exists(path))
return TRY(real_path(path)).to_byte_string();
return real_path(path);
if (path.starts_with("/"sv))
return LexicalPath::canonicalized_path(path);
@ -40,7 +40,7 @@ ErrorOr<ByteString> absolute_path(StringView path)
return LexicalPath::absolute_path(working_directory, path);
}
ErrorOr<String> real_path(StringView path)
ErrorOr<ByteString> real_path(StringView path)
{
if (path.is_null())
return Error::from_errno(ENOENT);
@ -52,7 +52,7 @@ ErrorOr<String> real_path(StringView path)
if (!real_path)
return Error::from_syscall("realpath"sv, -errno);
return TRY(String::from_utf8({ real_path, strlen(real_path) }));
return ByteString { real_path, strlen(real_path) };
}
bool exists(StringView path)
@ -244,12 +244,12 @@ ErrorOr<void> copy_directory(StringView destination_path, StringView source_path
TRY(Core::System::mkdir(destination_path, 0755));
auto source_rp = TRY(real_path(source_path));
source_rp = TRY(String::formatted("{}/", source_rp));
source_rp = ByteString::formatted("{}/", source_rp);
auto destination_rp = TRY(real_path(destination_path));
destination_rp = TRY(String::formatted("{}/", destination_rp));
destination_rp = ByteString::formatted("{}/", destination_rp);
if (!destination_rp.is_empty() && destination_rp.starts_with_bytes(source_rp))
if (!destination_rp.is_empty() && destination_rp.starts_with(source_rp))
return Error::from_errno(EINVAL);
Core::DirIterator di(source_path, Core::DirIterator::SkipParentAndBaseDir);

2
Userland/Libraries/LibFileSystem/FileSystem.h
View file

@ -20,7 +20,7 @@ namespace FileSystem {
ErrorOr<ByteString> current_working_directory();
ErrorOr<ByteString> absolute_path(StringView path);
ErrorOr<String> real_path(StringView path);
ErrorOr<ByteString> real_path(StringView path);
bool exists(StringView path);
bool exists(int fd);

4
Userland/Libraries/LibGUI/FileIconProvider.cpp
View file

@ -259,9 +259,9 @@ Icon FileIconProvider::icon_for_path(StringView path, mode_t mode)
auto raw_symlink_target_or_error = FileSystem::read_link(path);
if (raw_symlink_target_or_error.is_error())
return s_symlink_icon;
auto raw_symlink_target = raw_symlink_target_or_error.release_value();
auto raw_symlink_target = raw_symlink_target_or_error.release_value().to_byte_string();
String target_path;
ByteString target_path;
if (raw_symlink_target.starts_with('/')) {
target_path = raw_symlink_target;
} else {

4
Userland/Libraries/LibIDL/IDLParser.cpp
View file

@ -144,7 +144,7 @@ Optional<Interface&> Parser::resolve_import(auto path)
auto real_path_error_or = FileSystem::real_path(include_path);
if (real_path_error_or.is_error())
report_parsing_error(ByteString::formatted("Failed to resolve path {}: {}", include_path, real_path_error_or.error()), filename, input, lexer.tell());
auto real_path = real_path_error_or.release_value().to_byte_string();
auto real_path = real_path_error_or.release_value();
if (top_level_resolved_imports().contains(real_path))
return *top_level_resolved_imports().find(real_path)->value;
@ -966,7 +966,7 @@ Interface& Parser::parse()
report_parsing_error(ByteString::formatted("Failed to resolve path '{}': {}", filename, this_module_or_error.error()), filename, input, 0);
VERIFY_NOT_REACHED();
}
auto this_module = this_module_or_error.release_value().to_byte_string();
auto this_module = this_module_or_error.release_value();
auto interface_ptr = make<Interface>();
auto& interface = *interface_ptr;

4
Userland/Libraries/LibTest/JavaScriptTestRunnerMain.cpp
View file

@ -174,14 +174,14 @@ int main(int argc, char** argv)
warnln("Failed to resolve test root: {}", test_root_or_error.error());
return 1;
}
test_root = test_root_or_error.release_value().to_byte_string();
test_root = test_root_or_error.release_value();
auto common_path_or_error = FileSystem::real_path(common_path);
if (common_path_or_error.is_error()) {
warnln("Failed to resolve common path: {}", common_path_or_error.error());
return 1;
}
common_path = common_path_or_error.release_value().to_byte_string();
common_path = common_path_or_error.release_value();
if (chdir(test_root.characters()) < 0) {
auto saved_errno = errno;

2
Userland/Libraries/LibWebView/URL.cpp
View file

@ -88,7 +88,7 @@ Optional<URL> sanitize_url(StringView url, Optional<StringView> search_engine, A
if (path.is_error())
return {};
return URL::create_with_file_scheme(path.value().to_byte_string());
return URL::create_with_file_scheme(path.value());
}
auto format_search_engine = [&]() -> Optional<URL> {

2
Userland/Services/FileSystemAccessServer/ConnectionFromClient.cpp
View file

@ -56,7 +56,7 @@ void ConnectionFromClient::request_file_handler(i32 request_id, i32 window_serve
if (prompt == ShouldPrompt::Yes) {
VERIFY(window_server_client_id != -1 && parent_window_id != -1);
auto exe_name = LexicalPath::basename(exe_path.to_byte_string());
auto exe_name = LexicalPath::basename(exe_path);
auto text = String::formatted("Allow {} ({}) to {} \"{}\"?", exe_name, pid, access_string, path).release_value_but_fixme_should_propagate_errors();
auto result = GUI::MessageBox::try_show({}, window_server_client_id, parent_window_id, text, "File Permissions Requested"sv).release_value_but_fixme_should_propagate_errors();
approved = result == GUI::MessageBox::ExecResult::Yes;

2
Userland/Services/LaunchServer/Launcher.cpp
View file

@ -318,7 +318,7 @@ void Launcher::for_each_handler_for_path(ByteString const& path, Function<bool(H
}
auto real_path = real_path_or_error.release_value();
return for_each_handler_for_path(real_path.to_byte_string(), [&](auto const& handler) -> bool {
return for_each_handler_for_path(real_path, [&](auto const& handler) -> bool {
return f(handler);
});
}

3
Userland/Services/WebServer/main.cpp
View file

@ -68,7 +68,8 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
if (!username.is_empty() && !password.is_empty())
credentials = HTTP::HttpRequest::BasicAuthenticationCredentials { username, password };
WebServer::Configuration configuration(real_document_root_path, credentials);
// FIXME: This should accept a ByteString for the path instead.
WebServer::Configuration configuration(TRY(String::from_byte_string(real_document_root_path)), credentials);
Core::EventLoop loop;

2
Userland/Shell/Builtin.cpp
View file

@ -454,7 +454,7 @@ ErrorOr<int> Shell::builtin_cd(Main::Arguments arguments)
warnln("Invalid path '{}'", new_path);
return 1;
}
auto real_path = real_path_or_error.release_value().to_byte_string();
auto real_path = real_path_or_error.release_value();
if (cd_history.is_empty() || cd_history.last() != real_path)
cd_history.enqueue(real_path);

2
Userland/Shell/Shell.cpp
View file

@ -394,7 +394,7 @@ ByteString Shell::resolve_path(ByteString path) const
if (!path.starts_with('/'))
path = ByteString::formatted("{}/{}", cwd, path);
return FileSystem::real_path(path).release_value_but_fixme_should_propagate_errors().to_byte_string();
return FileSystem::real_path(path).release_value_but_fixme_should_propagate_errors();
}
Shell::LocalFrame* Shell::find_frame_containing_local_variable(StringView name)

2
Userland/Utilities/find.cpp
View file

@ -579,7 +579,7 @@ private:
auto full_path_or_error = FileSystem::real_path(file_data.full_path());
if (!full_path_or_error.is_error()) {
auto fullpath = full_path_or_error.release_value();
auto url = URL::create_with_file_scheme(fullpath.to_byte_string());
auto url = URL::create_with_file_scheme(fullpath);
out("\033]8;;{}\033\\{}{}\033]8;;\033\\", url.serialize(), file_data.full_path(), m_terminator);
printed = true;
}

2
Userland/Utilities/grep.cpp
View file

@ -88,7 +88,7 @@ static void append_formatted_path(StringBuilder& builder, StringView path, Optio
auto full_path_or_error = FileSystem::real_path(path);
if (!full_path_or_error.is_error()) {
auto fullpath = full_path_or_error.release_value();
auto url = URL::create_with_file_scheme(fullpath.to_byte_string(), {}, hostname());
auto url = URL::create_with_file_scheme(fullpath, {}, hostname());
if (has_flag(print_type, PrintType::LineNumbers) && line_number.has_value())
url.set_query(MUST(String::formatted("line_number={}", *line_number)));
builder.appendff("\033]8;;{}\033\\", url.serialize());

10
Userland/Utilities/headless-browser.cpp
View file

@ -264,7 +264,7 @@ static ErrorOr<TestResult> run_dump_test(HeadlessWebContentView& view, StringVie
loop.quit(0);
}));
auto url = URL::create_with_file_scheme(TRY(FileSystem::real_path(input_path)).to_byte_string());
auto url = URL::create_with_file_scheme(TRY(FileSystem::real_path(input_path)));
String result;
auto did_finish_test = false;
@ -359,7 +359,7 @@ static ErrorOr<TestResult> run_ref_test(HeadlessWebContentView& view, StringView
loop.quit(0);
}));
view.load(URL::create_with_file_scheme(TRY(FileSystem::real_path(input_path)).to_byte_string()));
view.load(URL::create_with_file_scheme(TRY(FileSystem::real_path(input_path))));
RefPtr<Gfx::Bitmap> actual_screenshot, expectation_screenshot;
view.on_load_finish = [&](auto const&) {
@ -478,7 +478,8 @@ static ErrorOr<void> collect_dump_tests(Vector<Test>& tests, StringView path, St
auto basename = LexicalPath::title(name);
auto expectation_path = TRY(String::formatted("{}/expected/{}/{}.txt", path, trail, basename));
tests.append({ move(input_path), move(expectation_path), mode, {} });
// FIXME: Test paths should be ByteString
tests.append({ TRY(String::from_byte_string(input_path)), move(expectation_path), mode, {} });
}
return {};
}
@ -489,7 +490,8 @@ static ErrorOr<void> collect_ref_tests(Vector<Test>& tests, StringView path)
if (entry.type == Core::DirectoryEntry::Type::Directory)
return IterationDecision::Continue;
auto input_path = TRY(FileSystem::real_path(TRY(String::formatted("{}/{}", path, entry.name))));
tests.append({ move(input_path), {}, TestMode::Ref, {} });
// FIXME: Test paths should be ByteString
tests.append({ TRY(String::from_byte_string(input_path)), {}, TestMode::Ref, {} });
return IterationDecision::Continue;
}));

2
Userland/Utilities/ls.cpp
View file

@ -267,7 +267,7 @@ static size_t print_name(const struct stat& st, ByteString const& name, Optional
auto full_path_or_error = FileSystem::real_path(path_for_hyperlink);
if (!full_path_or_error.is_error()) {
auto fullpath = full_path_or_error.release_value();
auto url = URL::create_with_file_scheme(fullpath.to_byte_string(), {}, hostname());
auto url = URL::create_with_file_scheme(fullpath, {}, hostname());
out("\033]8;;{}\033\\", url.serialize());
}
}

3
Userland/Utilities/markdown-check.cpp
View file

@ -301,6 +301,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
if (verbose_output)
outln("Reading and parsing Markdown files ...");
// FIXME: Use ByteString for file paths
HashMap<String, MarkdownLinkage> files;
for (auto path : file_paths) {
auto file_or_error = Core::File::open(path, Core::File::OpenMode::Read);
@ -326,7 +327,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
// Since this should never happen anyway, fail early.
return 1;
}
files.set(TRY(FileSystem::real_path(path)), MarkdownLinkage::analyze(*document, verbose_output));
files.set(TRY(String::from_byte_string(TRY(FileSystem::real_path(path)))), MarkdownLinkage::analyze(*document, verbose_output));
}
if (verbose_output)

2
Userland/Utilities/open.cpp
View file

@ -34,7 +34,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
continue;
}
} else {
url = URL::create_with_url_or_path(path_or_error.value().to_byte_string());
url = URL::create_with_url_or_path(path_or_error.value());
}
if (!Desktop::Launcher::open(url)) {

2
Userland/Utilities/run-tests.cpp
View file

@ -382,7 +382,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
return 1;
}
test_root = TRY(FileSystem::real_path(test_root)).to_byte_string();
test_root = TRY(FileSystem::real_path(test_root));
auto void_or_error = Core::System::chdir(test_root);
if (void_or_error.is_error()) {

2
Userland/Utilities/shot.cpp
View file

@ -179,7 +179,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
char hostname[HOST_NAME_MAX];
VERIFY(gethostname(hostname, sizeof(hostname)) == 0);
auto url = URL::create_with_file_scheme(full_path_or_error.value().to_byte_string(), {}, hostname);
auto url = URL::create_with_file_scheme(full_path_or_error.value(), {}, hostname);
out("\033]8;;{}\033\\", url.serialize());
printed_hyperlink = true;
}

4
Userland/Utilities/wasm.cpp
View file

@ -388,11 +388,11 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
for (auto& string : wasi_preopened_mappings) {
auto split_index = string.find(':');
if (split_index.has_value()) {
LexicalPath host_path { FileSystem::real_path(string.substring_view(0, *split_index)).release_value_but_fixme_should_propagate_errors().to_byte_string() };
LexicalPath host_path { FileSystem::real_path(string.substring_view(0, *split_index)).release_value_but_fixme_should_propagate_errors() };
LexicalPath mapped_path { string.substring_view(*split_index + 1) };
paths.append({move(host_path), move(mapped_path)});
} else {
LexicalPath host_path { FileSystem::real_path(string).release_value_but_fixme_should_propagate_errors().to_byte_string() };
LexicalPath host_path { FileSystem::real_path(string).release_value_but_fixme_should_propagate_errors() };
LexicalPath mapped_path { string };
paths.append({move(host_path), move(mapped_path)});
}

6
Userland/Utilities/xml.cpp
View file

@ -355,7 +355,7 @@ static void dump(XML::Document& document)
dump(document.root());
}
static String s_path;
static ByteString s_path;
static auto parse(StringView contents)
{
return XML::Parser {
@ -363,7 +363,7 @@ static auto parse(StringView contents)
{
.preserve_comments = true,
.resolve_external_resource = [&](XML::SystemID const& system_id, Optional<XML::PublicID> const&) -> ErrorOr<ByteString> {
auto base = URL::create_with_file_scheme(s_path.to_byte_string());
auto base = URL::create_with_file_scheme(s_path);
auto url = URLParser::basic_parse(system_id.system_literal, base);
if (!url.is_valid())
return Error::from_string_literal("Invalid URL");
@ -402,7 +402,7 @@ static void do_run_tests(XML::Document& document)
dump_cases(root);
auto base_path = LexicalPath::dirname(s_path.to_byte_string());
auto base_path = LexicalPath::dirname(s_path);
while (!suites.is_empty()) {
auto& node = *suites.dequeue();