Provide support for nested lists, reorganize some tests

Author: Nexushunter

openapi-generator/lib/src/gen_on_spec_changes.dart

@@ -149,29 +149,16 @@ bool isSpecDirty({
 /// Converts a [YamlMap] and it's children into a [Map]. This involes expanding
 /// [YamlList] & [YamlMap] nodes into their entries. [YamlScalar] values are
 /// directly set.
-///
-/// Currently this makes the assumption that [YamlList] node shouldn't be a valid
-/// child entry within another [YamlList] and ignores the contents.
 Map<String, dynamic> convertYamlMapToDartMap({required YamlMap yamlMap}) {
   final transformed = <String, dynamic>{};
 
   yamlMap.forEach((key, value) {
     late dynamic content;
     if (value is YamlList) {
       // Parse list entries
-      content = [];
-      value.forEach((element) {
-        if (element is YamlList) {
-          // TODO: Is this a potential case.
-          log('Found a YamlList within a YamlList');
-        } else if (element is YamlMap) {
-          content.add(convertYamlMapToDartMap(yamlMap: element));
-        } else {
-          content.add(element);
-        }
-      });
+      content = convertYamlListToDartList(yamlList: value);
     } else if (value is YamlMap) {
-      // Parse the sub mapyamlParsedMap
+      // Parse the sub map
       content = convertYamlMapToDartMap(
           yamlMap: YamlMap.internal(value.nodes, value.span, value.style));
     } else if (value is YamlScalar) {
@@ -187,6 +174,26 @@ Map<String, dynamic> convertYamlMapToDartMap({required YamlMap yamlMap}) {
   return transformed;
 }
 
+/// Converts the given [yamlList] into a Dart [List].
+///
+/// Recursively converts the given [yamlList] to a Dart [List]; converting all
+/// nested lists into their constituent values.
+List<dynamic> convertYamlListToDartList({required YamlList yamlList}) {
+  final converted = [];
+
+  yamlList.forEach((element) {
+    if (element is YamlList) {
+      converted.add(convertYamlListToDartList(yamlList: element));
+    } else if (element is YamlMap) {
+      converted.add(convertYamlMapToDartMap(yamlMap: element));
+    } else {
+      converted.add(element);
+    }
+  });
+
+  return converted;
+}
+
 Future<void> cacheSpec({
   required String outputDirectory,
   required Map<String, dynamic> spec,

openapi-generator/test/gen_on_spec_changes_test.dart

@@ -49,6 +49,24 @@ void main() {
             fail('should have successfully loaded json spec');
           }
         });
+        test('yaml (requires transformation)', () async {
+          try {
+            final loaded =
+                await loadSpec(specPath: supportedExtensions['yaml']!);
+            expect(loaded, jsonSpecFile);
+          } catch (_, __) {
+            fail('Should successfully convert yaml to Map');
+          }
+        });
+        test('yml (requires transformation)', () async {
+          try {
+            final loaded =
+                await loadSpec(specPath: supportedExtensions['yml']!);
+            expect(loaded, jsonSpecFile);
+          } catch (_, __) {
+            fail('Should successfully convert yml to Map');
+          }
+        });
       });
     });
     group('verifies dirty status', () {
@@ -127,37 +145,64 @@ void main() {
       });
     });
     group('transforms yaml to dart map', () {
-      test('returns a map from yaml', () async {
-        expect(await loadSpec(specPath: supportedExtensions['yaml']!),
-            jsonSpecFile);
-      });
-      test('returns a map from yml', () async {
-        expect(await loadSpec(specPath: supportedExtensions['yml']!),
-            jsonSpecFile);
-      });
       test('converts scalars', () {
         expect(convertYamlMapToDartMap(yamlMap: YamlMap.wrap({'scalar': 5})),
             {'scalar': 5});
       });
-      test('converts list', () {
-        final listContent = [
-          1,
-          2,
-          3,
-          4,
-          YamlMap.wrap(<String, dynamic>{'entry': 'value'})
-        ];
-        final listContentExpected = [
-          1,
-          2,
-          3,
-          4,
-          <String, dynamic>{'entry': 'value'}
-        ];
+      group('converts lists', () {
+        test('with YamlMaps', () {
+          final listContent = [
+            1,
+            2,
+            3,
+            4,
+            YamlMap.wrap(<String, dynamic>{'entry': 'value'})
+          ];
+          final listContentExpected = [
+            1,
+            2,
+            3,
+            4,
+            <String, dynamic>{'entry': 'value'}
+          ];
+          expect(
+              convertYamlListToDartList(yamlList: YamlList.wrap(listContent)),
+              listContentExpected);
+        });
+        test('with nested lists', () {
+          final listContent = [
+            1,
+            2,
+            3,
+            4,
+            YamlList.wrap(
+              ["one", "two", "three"],
+            )
+          ];
+          final listContentExpected = [
+            1,
+            2,
+            3,
+            4,
+            ["one", "two", "three"],
+          ];
+          expect(
+              convertYamlListToDartList(yamlList: YamlList.wrap(listContent)),
+              listContentExpected);
+        });
+      });
+      test('converts submap to map', () {
+        final expectedMap = <String, dynamic>{
+          'mapWithSubMap': {
+            'subMap': {'scalar': 5, 'meh': 'value'},
+          }
+        };
         expect(
             convertYamlMapToDartMap(
-                yamlMap: YamlMap.wrap({'scalar': YamlList.wrap(listContent)})),
-            {'scalar': listContentExpected});
+                yamlMap: YamlMap.wrap({
+              'mapWithSubMap': YamlMap.wrap(expectedMap['mapWithSubMap'])
+            })),
+            expectedMap);
       });
     });
   });