Reworked keep prefix (#7456)

* reworked keep prefix

* checking in missing schema

* fix flatc path for build scripts

.github/workflows/build.yml

@@ -80,6 +80,8 @@ jobs:
       run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64
     - name: test
       run: Release\flattests.exe
+    - name: flatc tests
+      run: python3 tests/flatc/main.py --flatc Release\flatc.exe
     - name: upload build artifacts
       uses: actions/upload-artifact@v1
       with:
@@ -181,6 +183,8 @@ jobs:
       run: |
         chmod +x _build/Release/flatc
         ./_build/Release/flatc --version
+    - name: flatc tests
+      run: python3 tests/flatc/main.py --flatc ./_build/Release/flatc
     - name: upload build artifacts
       uses: actions/upload-artifact@v1
       with:

src/idl_gen_cpp.cpp

@@ -239,22 +239,34 @@ class CppGenerator : public BaseGenerator {
     // interdependence between them.
     std::stable_sort(included_files.begin(), included_files.end());
 
-    // Get any prefix of the file being parsed, so that included filed can be
+    // The absolute path of the file being parsed.
-    // properly stripped.
+    const std::string parsed_path =
-    auto prefix = flatbuffers::StripFileName(parser_.file_being_parsed_) +
+        flatbuffers::StripFileName(AbsolutePath(parser_.file_being_parsed_));
-                  flatbuffers::kPathSeparator;
 
     for (const std::string &included_file : included_files) {
-      auto file_without_extension = flatbuffers::StripExtension(included_file);
+      // The base name of the file, without path or extensions.
-      code_ +=
+      std::string basename =
-          "#include \"" +
+          flatbuffers::StripPath(flatbuffers::StripExtension(included_file));
-          GeneratedFileName(
+
-              opts_.include_prefix,
+      // If we are keeping the prefix
-              opts_.keep_prefix
+      if (opts_.keep_prefix) {
-                  ? flatbuffers::StripPrefix(file_without_extension, prefix)
+        // The absolute path of the included file.
-                  : flatbuffers::StripPath(file_without_extension),
+        const std::string included_path =
-              opts_) +
+            flatbuffers::StripFileName(AbsolutePath(included_file));
-          "\"";
+
+        // The relative path of the parsed file to the included file.
+        const std::string relative_path =
+            RelativeToRootPath(parsed_path, included_path).substr(2);
+
+        // Only consider cases where the included path is a subdirectory of the
+        // parsed path.
+        if (strncmp("..", relative_path.c_str(), 2) != 0) {
+          basename = relative_path + kPathSeparator + basename;
+        }
+      }
+
+      code_ += "#include \"" +
+               GeneratedFileName(opts_.include_prefix, basename, opts_) + "\"";
     }
 
     if (!parser_.native_included_files_.empty() || !included_files.empty()) {

tests/flatc/bar/bar_with_foo.fbs

@@ -0,0 +1,6 @@
+include "foo.fbs";
+include "baz/baz.fbs";
+
+table BarWithFoo {
+  foo:Foo;
+}

tests/flatc/flatc_cpp_tests.py

@@ -14,141 +14,241 @@
 
 from flatc_test import *
 
-class CppTests():
 
-  def Flatten(self):
+class CppTests:
-    # Generate just foo with a "flatten" import of bar.
+    def Flatten(self):
-    flatc(["--cpp", "foo.fbs"])
+        # Generate just foo with a "flatten" import of bar.
+        flatc(["--cpp", "foo.fbs"])
 
-    # Foo should be generated in place and include bar flatten
+        # Foo should be generated in place and include bar flatten
-    assert_file_and_contents("foo_generated.h", '#include "bar_generated.h"')
+        assert_file_and_contents("foo_generated.h", '#include "bar_generated.h"')
 
-  def FlattenAbsolutePath(self):
+    def FlattenAbsolutePath(self):
-    # Generate just foo with a "flatten" import of bar.
+        # Generate just foo with a "flatten" import of bar.
-    flatc(["--cpp", make_absolute("foo.fbs")])
+        flatc(["--cpp", make_absolute("foo.fbs")])
 
-    # Foo should be generated in place and include bar flatten
+        # Foo should be generated in place and include bar flatten
-    assert_file_and_contents("foo_generated.h", '#include "bar_generated.h"')
+        assert_file_and_contents("foo_generated.h", '#include "bar_generated.h"')
 
-  def FlattenSubDirectory(self):
+    def FlattenSubDirectory(self):
-    # Generate just foo with a "flatten" import of bar.
+        # Generate just foo with a "flatten" import of bar.
-    flatc(["--cpp", "bar/bar.fbs"])
+        flatc(["--cpp", "bar/bar.fbs"])
-    
-    # Bar should be generated in place and include baz
-    assert_file_and_contents("bar_generated.h", '#include "baz_generated.h"')
 
-  def FlattenOutPath(self):
+        # Bar should be generated in place and include baz
-    # Generate just foo with a "flatten" import of bar.
+        assert_file_and_contents("bar_generated.h", '#include "baz_generated.h"')
-    flatc(["--cpp", "-o", ".tmp", "foo.fbs"])
 
-    # Foo should be generated in the out path and include bar flatten to the out path.
+    def FlattenOutPath(self):
-    assert_file_and_contents(".tmp/foo_generated.h", '#include "bar_generated.h"')
+        # Generate just foo with a "flatten" import of bar.
+        flatc(["--cpp", "-o", ".tmp", "foo.fbs"])
 
-  def FlattenOutPathSuperDirectory(self):
+        # Foo should be generated in the out path and include bar flatten to the out path.
-    # Generate just foo with a "flatten" import of bar.
+        assert_file_and_contents(".tmp/foo_generated.h", '#include "bar_generated.h"')
-    flatc(["--cpp", "-o", "../.tmp", "foo.fbs"])
 
-    # Foo should be generated in the out path and include bar flatten to the out path.
+    def FlattenOutPathSuperDirectory(self):
-    assert_file_and_contents("../.tmp/foo_generated.h", '#include "bar_generated.h"')
+        # Generate just foo with a "flatten" import of bar.
+        flatc(["--cpp", "-o", "../.tmp", "foo.fbs"])
 
-  def FlattenOutPathSubDirectory(self):
+        # Foo should be generated in the out path and include bar flatten to the out path.
-    # Generate just foo with a "flatten" import of bar.
+        assert_file_and_contents(
-    flatc(["--cpp", "-o", ".tmp", "bar/bar.fbs"])
+            "../.tmp/foo_generated.h", '#include "bar_generated.h"'
+        )
 
-    # Bar should be generated in the out path and include baz flatten to the out path.
+    def FlattenOutPathSubDirectory(self):
-    assert_file_and_contents(".tmp/bar_generated.h", '#include "baz_generated.h"')
+        # Generate just foo with a "flatten" import of bar.
+        flatc(["--cpp", "-o", ".tmp", "bar/bar.fbs"])
 
-  def KeepPrefix(self):
+        # Bar should be generated in the out path and include baz flatten to the out path.
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
+        assert_file_and_contents(".tmp/bar_generated.h", '#include "baz_generated.h"')
-    flatc(["--cpp", "--keep-prefix", "foo.fbs"])
 
-    assert_file_and_contents("foo_generated.h", '#include "bar/bar_generated.h"')
+    def KeepPrefix(self):
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--keep-prefix", "foo.fbs"])
 
-  def KeepPrefixAbsolutePath(self):
+        assert_file_and_contents("foo_generated.h", '#include "bar/bar_generated.h"')
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
-    flatc(["--cpp", "--keep-prefix", make_absolute("foo.fbs")])
 
-    assert_file_and_contents("foo_generated.h", '#include "bar/bar_generated.h"')
+    def KeepPrefixAbsolutePath(self):
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--keep-prefix", make_absolute("foo.fbs")])
 
-  def KeepPrefixSubDirectory(self):
+        assert_file_and_contents("foo_generated.h", '#include "bar/bar_generated.h"')
-    # Generate with the import of bar keeping the prefix of where it is located.
-    flatc(["--cpp", "--keep-prefix", "bar/bar.fbs"])
 
-    assert_file_and_contents("bar_generated.h", '#include "baz/baz_generated.h"')
+    def KeepPrefixSubDirectory(self):
+        # Generate with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--keep-prefix", "bar/bar.fbs"])
 
-  def KeepPrefixOutPath(self):
+        assert_file_and_contents("bar_generated.h", '#include "baz/baz_generated.h"')
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
-    flatc(["--cpp", "--keep-prefix", "-o", ".tmp", "foo.fbs"])
 
-    assert_file_and_contents(".tmp/foo_generated.h", '#include "bar/bar_generated.h"')
+    def KeepPrefixOutPath(self):
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--keep-prefix", "-o", ".tmp", "foo.fbs"])
 
-  def KeepPrefixOutPathSubDirectory(self):
+        assert_file_and_contents(
-    # Generate with the import of bar keeping the prefix of where it is located.
+            ".tmp/foo_generated.h",
-    flatc(["--cpp", "--keep-prefix", "-o", ".tmp", "bar/bar.fbs"])
+            '#include "bar/bar_generated.h"',
+        )
 
-    assert_file_and_contents(".tmp/bar_generated.h", '#include "baz/baz_generated.h"')
+    def KeepPrefixOutPathSubDirectory(self):
+        # Generate with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--keep-prefix", "-o", ".tmp", "bar/bar.fbs"])
 
-  def IncludePrefix(self):
+        assert_file_and_contents(
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
+            ".tmp/bar_generated.h", '#include "baz/baz_generated.h"'
-    flatc(["--cpp", "--include-prefix", "test", "foo.fbs"])
+        )
 
-    assert_file_and_contents("foo_generated.h", '#include "test/bar_generated.h"')
+    def IncludePrefix(self):
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--include-prefix", "test", "foo.fbs"])
 
-  def IncludePrefixAbolutePath(self):
+        assert_file_and_contents("foo_generated.h", '#include "test/bar_generated.h"')
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
-    flatc(["--cpp", "--include-prefix", "test", make_absolute("foo.fbs")])
 
-    assert_file_and_contents("foo_generated.h", '#include "test/bar_generated.h"')
+    def IncludePrefixAbolutePath(self):
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--include-prefix", "test", make_absolute("foo.fbs")])
 
-  def IncludePrefixSubDirectory(self):
+        assert_file_and_contents("foo_generated.h", '#include "test/bar_generated.h"')
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
-    flatc(["--cpp", "--include-prefix", "test", "bar/bar.fbs"])
 
-    assert_file_and_contents("bar_generated.h", '#include "test/baz_generated.h"')
+    def IncludePrefixSubDirectory(self):
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--include-prefix", "test", "bar/bar.fbs"])
 
-  def IncludePrefixOutPath(self):
+        assert_file_and_contents("bar_generated.h", '#include "test/baz_generated.h"')
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
-    flatc(["--cpp", "--include-prefix", "test", "-o", ".tmp", "foo.fbs"])
 
-    assert_file_and_contents(".tmp/foo_generated.h", '#include "test/bar_generated.h"')
+    def IncludePrefixOutPath(self):
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--include-prefix", "test", "-o", ".tmp", "foo.fbs"])
 
-  def IncludePrefixOutPathSubDirectory(self):
+        assert_file_and_contents(
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
+            ".tmp/foo_generated.h", '#include "test/bar_generated.h"'
-    flatc(["--cpp", "--include-prefix", "test", "-o", ".tmp", "bar/bar.fbs"])
+        )
 
-    assert_file_and_contents(".tmp/bar_generated.h", '#include "test/baz_generated.h"')
+    def IncludePrefixOutPathSubDirectory(self):
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--include-prefix", "test", "-o", ".tmp", "bar/bar.fbs"])
 
-  def KeepPrefixIncludePrefix(self):
+        assert_file_and_contents(
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
+            ".tmp/bar_generated.h", '#include "test/baz_generated.h"'
-    flatc(["--cpp", "--keep-prefix", "--include-prefix", "test", "foo.fbs"])
+        )
 
-    # The include prefix should come first, with the kept prefix next.
+    def KeepPrefixIncludePrefix(self):
-    assert_file_and_contents("foo_generated.h", '#include "test/bar/bar_generated.h"')
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--keep-prefix", "--include-prefix", "test", "foo.fbs"])
 
-  def KeepPrefixIncludePrefixAbsolutePath(self):
+        # The include prefix should come first, with the kept prefix next.
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
+        assert_file_and_contents(
-    flatc(["--cpp", "--keep-prefix", "--include-prefix", "test", make_absolute("foo.fbs")])
+            "foo_generated.h", '#include "test/bar/bar_generated.h"'
+        )
 
-    # The include prefix should come first, with the kept prefix next.
+    def KeepPrefixIncludePrefixAbsolutePath(self):
-    assert_file_and_contents("foo_generated.h", '#include "test/bar/bar_generated.h"')
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(
+            [
+                "--cpp",
+                "--keep-prefix",
+                "--include-prefix",
+                "test",
+                make_absolute("foo.fbs"),
+            ]
+        )
 
-  def KeepPrefixIncludePrefixSubDirectory(self):
+        # The include prefix should come first, with the kept prefix next.
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
+        assert_file_and_contents(
-    flatc(["--cpp", "--keep-prefix", "--include-prefix", "test", "bar/bar.fbs"])
+            "foo_generated.h", '#include "test/bar/bar_generated.h"'
+        )
 
-    # The include prefix should come first, with the kept prefix next.
+    def KeepPrefixIncludePrefixSubDirectory(self):
-    assert_file_and_contents("bar_generated.h", '#include "test/baz/baz_generated.h"')
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(["--cpp", "--keep-prefix", "--include-prefix", "test", "bar/bar.fbs"])
 
-  def KeepPrefixIncludePrefixOutPathSubDirectory(self):
+        # The include prefix should come first, with the kept prefix next.
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
+        assert_file_and_contents(
-    flatc(["--cpp", "--keep-prefix", "--include-prefix", "test", "-o", ".tmp", "bar/bar.fbs"])
+            "bar_generated.h", '#include "test/baz/baz_generated.h"'
+        )
 
-    # The include prefix should come first, with the kept prefix next.
+    def KeepPrefixIncludePrefixOutPathSubDirectory(self):
-    assert_file_and_contents(".tmp/bar_generated.h", '#include "test/baz/baz_generated.h"')
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(
+            [
+                "--cpp",
+                "--keep-prefix",
+                "--include-prefix",
+                "test",
+                "-o",
+                ".tmp",
+                "bar/bar.fbs",
+            ]
+        )
 
-  def KeepPrefixIncludePrefixOutPathSuperDirectory(self):
+        # The include prefix should come first, with the kept prefix next.
-    # Generate just foo with the import of bar keeping the prefix of where it is located.
+        assert_file_and_contents(
-    flatc(["--cpp", "--keep-prefix", "--include-prefix", "test", "-o", "../.tmp", "bar/bar.fbs"])
+            ".tmp/bar_generated.h", '#include "test/baz/baz_generated.h"'
+        )
 
-    # The include prefix should come first, with the kept prefix next.
+    def KeepPrefixIncludePrefixOutPathSuperDirectory(self):
-    assert_file_and_contents("../.tmp/bar_generated.h", '#include "test/baz/baz_generated.h"')
+        # Generate just foo with the import of bar keeping the prefix of where it is located.
+        flatc(
+            [
+                "--cpp",
+                "--keep-prefix",
+                "--include-prefix",
+                "test",
+                "-o",
+                "../.tmp",
+                "bar/bar.fbs",
+            ]
+        )
+
+        # The include prefix should come first, with the kept prefix next.
+        assert_file_and_contents(
+            "../.tmp/bar_generated.h", '#include "test/baz/baz_generated.h"'
+        )
+
+    def KeepPrefixIncludePrefixoutPathAbsoluePaths_SuperDirectoryReference(self):
+        # Generate bar_with_foo that references a type in a super directory.
+        flatc(
+            [
+                "--cpp",
+                "--keep-prefix",
+                "--include-prefix",
+                "generated",
+                "-I",
+                str(script_path.absolute()),
+                "-o",
+                str(Path(script_path, ".tmp").absolute()),
+                str(Path(script_path, "bar/bar_with_foo.fbs").absolute()),
+            ]
+        )
+
+        # The include prefix should come first, with the kept prefix next.
+        assert_file_and_contents(
+            ".tmp/bar_with_foo_generated.h",
+            [
+                '#include "generated/baz/baz_generated.h"',
+                '#include "generated/foo_generated.h"',
+            ],
+        )
+
+    def KeepPrefixIncludePrefixoutPath_SuperDirectoryReference(self):
+        # Generate bar_with_foo that references a type in a super directory.
+        flatc(
+            [
+                "--cpp",
+                "--keep-prefix",
+                "--include-prefix",
+                "generated",
+                "-I",
+                "./",
+                "-o",
+                ".tmp",
+                "bar/bar_with_foo.fbs",
+            ]
+        )
+
+        # The include prefix should come first, with the kept prefix next.
+        assert_file_and_contents(
+            ".tmp/bar_with_foo_generated.h",
+            [
+                '#include "generated/baz/baz_generated.h"',
+                '#include "generated/foo_generated.h"',
+            ],
+            unlink=False,
+        )

tests/flatc/flatc_test.py

@@ -52,7 +52,7 @@ def flatc(options, cwd=script_path):
 
 
 def make_absolute(filename, path=script_path):
-    return Path(path, filename).absolute()
+    return str(Path(path, filename).absolute())
 
 
 def assert_file_exists(filename, path=script_path):

tests/flatc/main.py

@@ -27,5 +27,3 @@ print("{0} of {1} tests passed".format(passing, passing + failing))
 
 if failing > 0:
     sys.exit(1)
-
-# TsTests().Base()