diff --git a/sdf/CMakeLists.txt b/sdf/CMakeLists.txt index 127458d91..4691138ec 100644 --- a/sdf/CMakeLists.txt +++ b/sdf/CMakeLists.txt @@ -12,10 +12,14 @@ add_subdirectory(1.10) add_custom_target(schema) add_dependencies(schema schema1_10) +if (NOT Python3_Interpreter_FOUND) + gz_build_error("Python is required to generate the C++ file with the SDF content") +endif() + # Generate the EmbeddedSdf.cc file, which contains all the supported SDF # descriptions in a map of strings. The parser.cc file uses EmbeddedSdf.hh. execute_process( - COMMAND ${RUBY} ${CMAKE_SOURCE_DIR}/sdf/embedSdf.rb + COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/sdf/embedSdf.py WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/sdf" OUTPUT_FILE "${PROJECT_BINARY_DIR}/src/EmbeddedSdf.cc" ) diff --git a/sdf/embedSdf.py b/sdf/embedSdf.py new file mode 100644 index 000000000..b89607fa6 --- /dev/null +++ b/sdf/embedSdf.py @@ -0,0 +1,151 @@ +#!/usr/bin/env python3 +import inspect +from pathlib import Path, PurePosixPath + +""""Script for generating a C++ file that contains the content from all SDF files""" + +# The list of supported SDF specification versions. This will let us drop +# versions without removing the directories. +SUPPORTED_SDF_VERSIONS = ['1.10', '1.9', '1.8', '1.7', '1.6', '1.5', '1.4', '1.3', '1.2'] + +# The list of supported SDF conversions. This list includes versions that +# a user can convert an existing SDF version to. +SUPPORTED_SDF_CONVERSIONS = ['1.10', '1.9', '1.8', '1.7', '1.6', '1.5', '1.4', '1.3'] + +# whitespace indentation for C++ code +INDENTATION = ' ' +# newline character +NEWLINE = '\n' + +def get_copyright_notice() -> str: + """ + Provides the copyrigt notice for the C++ file + + :returns: copyright notice + """ + res = inspect.cleandoc(""" + /* + * Copyright 2022 Open Source Robotics Foundation + * + * 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. + * + */ + """) + return res + 2*NEWLINE + + +def get_file_header_prolog() -> str: + """ + Provides the include statement, namespace and variable declaration of the C++ file + + :returns: prolog of the C++ file + """ + res = inspect.cleandoc(""" + #include "EmbeddedSdf.hh" + + namespace sdf + { + inline namespace SDF_VERSION_NAMESPACE + { + ///////////////////////////////////////////////// + const std::map &GetEmbeddedSdf() + { + static const std::map result { + """) + return res + NEWLINE + + +def embed_sdf_content(arg_path: str, arg_file_content: str) -> str: + """ + Generates a string pair with the folder and filename as well as the content of the file + + :param arg_path: Foldername and filename of the SDF + :param arg_file_content: Content of the provided file + :returns: raw string literal mapping pair for the std::map + """ + res = [] + res.append('// NOLINT') + res.append('{') + res.append(f'"{arg_path}",') + res.append('R"__sdf_literal__(') + res.append(f'{arg_file_content}') + res.append(')__sdf_literal__"') + res.append('},') + res.append('') + return NEWLINE.join(res) + + +def get_map_content(arg_pathlist: Path) -> str: + """ + Generates a string pair with the folder and filename as well as the content + of the file in ascending order + + :param arg_pathlist: Foldername and all filenames inside it + :returns: mapping pairs for the std::map + """ + map_str = '' + files = [] + for path in arg_pathlist: + # dir separator is hardcoded to '/' in C++ mapping + posix_path = PurePosixPath(path) + files.append(str(posix_path)) + # get ascending order + files.sort() + for file in files: + with Path(file).open() as f: + content = f.read() + map_str += embed_sdf_content(file, content) + return map_str + + +def get_file_header_epilog() -> str: + """ + Provides the return statement and the closing brackets of the C++ file + + :returns: epilog of the C++ file + """ + res = inspect.cleandoc(""" + }; + + return result; + } + + } + } // namespace sdf + + """) + return NEWLINE + res + + +if __name__ == "__main__": + copyright = get_copyright_notice() + prolog = get_file_header_prolog() + + map_str = "" + for sdf_version in SUPPORTED_SDF_VERSIONS: + pathlist = Path(sdf_version).glob('*.sdf') + map_str += get_map_content(pathlist) + + for sdf_conversion in SUPPORTED_SDF_CONVERSIONS: + pathlist = Path(sdf_conversion).glob('*.convert') + map_str += get_map_content(pathlist) + + # remove the last comma + map_str = map_str[:-2] + + epilog = get_file_header_epilog() + + output = copyright + prolog + map_str + epilog + + # output to stdin so that CMake can read it and create the appropriate file + print(output) diff --git a/sdf/embedSdf.rb b/sdf/embedSdf.rb deleted file mode 100755 index 488ff698d..000000000 --- a/sdf/embedSdf.rb +++ /dev/null @@ -1,45 +0,0 @@ -#!/usr/bin/env ruby - -# The list of supported SDF specification versions. This will let us drop -# versions without removing the directories. -supportedSdfVersions = ['1.10', '1.9', '1.8', '1.7', '1.6', '1.5', '1.4', '1.3', '1.2'] - -# The list of supported SDF conversions. This list includes versions that -# a user can convert an existing SDF version to. -supportedSdfConversions = ['1.10', '1.9', '1.8', '1.7', '1.6', '1.5', '1.4', '1.3'] - -puts %q! -#include "EmbeddedSdf.hh" - -namespace sdf { -inline namespace SDF_VERSION_NAMESPACE { - -const std::map &GetEmbeddedSdf() { - static const std::map result{ -! - -# Stores the contents of the file in the map. -def embed(pathname) - puts "{\"#{pathname}\", R\"__sdf_literal__(" - infile = File.open(pathname) - puts infile.read - puts ")__sdf_literal__\"}," -end - -# Embed the supported *.sdf files. -supportedSdfVersions.each do |version| - Dir.glob("#{version}/*.sdf").sort.each { |file| embed(file) } -end - -# Embed the supported *.convert files. -supportedSdfConversions.each do |version| - Dir.glob("#{version}/*.convert").sort.each { |file| embed(file) } -end -puts %q! - }; - return result; -} - -} -} -! diff --git a/src/SDF_TEST.cc b/src/SDF_TEST.cc index ca14549df..315343e12 100644 --- a/src/SDF_TEST.cc +++ b/src/SDF_TEST.cc @@ -21,6 +21,9 @@ #include #include +#include "test_config.hh" +#include "test_utils.hh" + #include "sdf/sdf.hh" class SDFUpdateFixture @@ -559,6 +562,59 @@ TEST(SDF, Version) EXPECT_STREQ(SDF_VERSION, sdf::SDF::Version().c_str()); } +///////////////////////////////////////////////// +TEST(SDF, EmbeddedSpec) +{ + std::string result; + + result = sdf::SDF::EmbeddedSpec("actor.sdf", false); + EXPECT_NE(result.find(""), std::string::npos); + EXPECT_NE(result.find(""), + std::string::npos); + result = sdf::SDF::EmbeddedSpec("actor.sdf", true); + EXPECT_NE(result.find(""), std::string::npos); + EXPECT_NE(result.find(""), + std::string::npos); + + result = sdf::SDF::EmbeddedSpec("root.sdf", false); + EXPECT_NE(result.find("SDFormat base element"), std::string::npos); + EXPECT_NE(result.find("name=\"version\" type=\"string\""), std::string::npos); + result = sdf::SDF::EmbeddedSpec("root.sdf", true); + EXPECT_NE(result.find("SDFormat base element"), std::string::npos); + EXPECT_NE(result.find("name=\"version\" type=\"string\""), std::string::npos); +} + +TEST(SDF, EmbeddedSpecNonExistent) +{ + std::string result; + + // Capture sdferr output + std::stringstream stderr_buffer; + sdf::testing::RedirectConsoleStream redir( + sdf::Console::Instance()->GetMsgStream(), &stderr_buffer); +#ifdef _WIN32 + sdf::Console::Instance()->SetQuiet(false); + sdf::testing::ScopeExit revertSetQuiet( + [] + { + sdf::Console::Instance()->SetQuiet(true); + }); +#endif + + result = sdf::SDF::EmbeddedSpec("unavailable.sdf", false); + EXPECT_NE(stderr_buffer.str().find("Unable to find SDF filename"), + std::string::npos); + EXPECT_NE(stderr_buffer.str().find("with version"), std::string::npos); + EXPECT_TRUE(result.empty()); + + // clear the contents of the buffer + stderr_buffer.str(""); + + result = sdf::SDF::EmbeddedSpec("unavailable.sdf", true); + EXPECT_TRUE(stderr_buffer.str().empty()); + EXPECT_TRUE(result.empty()); +} + ///////////////////////////////////////////////// TEST(SDF, FilePath) {