Merge 2d375e3 into f39f571

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"
 )

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<std::string, std::string> &GetEmbeddedSdf()
+    {
+        static const std::map<std::string, std::string> 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)

src/SDF_TEST.cc

@@ -21,6 +21,9 @@
 #include <gz/utils/Environment.hh>
 #include <gz/utils/SuppressWarning.hh>
 
+#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("<!-- Actor -->"), std::string::npos);
+  EXPECT_NE(result.find("<element name=\"actor\" required=\"*\">"),
+      std::string::npos);
+  result = sdf::SDF::EmbeddedSpec("actor.sdf", true);
+  EXPECT_NE(result.find("<!-- Actor -->"), std::string::npos);
+  EXPECT_NE(result.find("<element name=\"actor\" required=\"*\">"),
+      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)
 {