(WIP) Large refactor to get things moving in a nicer way. Adds ~80 tests.

Author: Nexushunter

openapi-generator-annotations/example/example.dart

@@ -5,5 +5,8 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart
         AdditionalProperties(pubName: 'petstore_api', pubAuthor: 'Johnny dep'),
     inputSpecFile: 'example/openapi-spec.yaml',
     generatorName: Generator.dio,
-    outputDirectory: 'api/petstore_api')
+    outputDirectory: 'api/petstore_api',
+    // useNextGen: true,
+    cachePath: 'something'
+)
 class Example extends OpenapiGeneratorConfig {}

openapi-generator-annotations/lib/src/openapi_generator_annotations_base.dart

@@ -54,6 +54,7 @@ class Openapi {
   /// --reserved-words-mappings
   final Map<String, String>? reservedWordsMappings;
 
+
   /// Tells openapi-generator to always run during the build process
   /// if set to false (the default), openapi-generator will skip processing if the [outputDirectory] already exists
   final bool? alwaysRun;
@@ -94,8 +95,19 @@ class Openapi {
   /// e.g {'inline_object_2': 'SomethingMapped'}
   final Map<String, String>? inlineSchemaNameMappings;
 
+  /// Use the next generation of the generator.
+  ///
+  /// Default: false
+  final bool useNextGen;
+
+  /// The path where to store the cached copy of the specification.
+  ///
+  /// For use with [useNextGen].
+  final String? cachePath;
+
   const Openapi(
       {this.additionalProperties,
+      @deprecated
       this.overwriteExistingFiles,
       this.skipSpecValidation = false,
       required this.inputSpecFile,
@@ -110,7 +122,10 @@ class Openapi {
       this.apiPackage,
       this.fetchDependencies = true,
       this.runSourceGenOnOutput = true,
-      this.alwaysRun = false});
+      @deprecated
+      this.alwaysRun = false,
+      this.cachePath,
+      this.useNextGen = false,}): assert(cachePath != null && !useNextGen, 'useNextGen should be set when providing cachePath');
 }
 
 class AdditionalProperties {

openapi-generator-annotations/test/openapi_generator_annotations_test.dart

@@ -1,15 +1,18 @@
+import 'package:openapi_generator_annotations/src/openapi_generator_annotations_base.dart';
 import 'package:test/test.dart';
 
 void main() {
-  group('A group of tests', () {
-//    Awesome awesome;
-//
-//    setUp(() {
-//      awesome = Awesome();
-//    });
-//
-//    test('First Test', () {
-//      expect(awesome.isAwesome, isTrue);
-//    });
+  group('OpenApi', () {
+    group('NextGen', (){
+
+      test('Sets cachePath',(){
+        final api =Openapi(inputSpecFile: '', generatorName: Generator.dart, cachePath: 'somePath');
+        expect(api.cachePath, 'somePath');
+      });
+    test('Sets useNextGenFlag',(){
+        final api =Openapi(inputSpecFile: '', generatorName: Generator.dart, useNextGen: true);
+        expect(api.useNextGen, isTrue);
+    });
+    });
   });
 }

openapi-generator/.gitignore

@@ -166,3 +166,6 @@ Temporary Items
 .apdisk
 .idea/
 example/.dart_tool
+
+# Generated test output
+test/specs/test-cached.json

openapi-generator/lib/src/determine_flutter_project_status.dart

@@ -0,0 +1,44 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:openapi_generator_annotations/openapi_generator_annotations.dart';
+import 'package:yaml/yaml.dart';
+
+/// Determines whether a project has a dependency on the Flutter sdk.
+///
+/// If a wrapper annotation is provided that is not null or [Wrapper.none] and
+/// is one of [Wrapper.flutterw] or [Wrapper.fvm] it is safe to assume the project
+/// requires the Flutter sdk.
+///
+/// As a fallback we check the pubspec at the root of the current directory, which
+/// will be where the build_runner command will have been called from, and check
+/// the Pubspec's dependency list for the 'flutter' key.
+///
+/// Note: This has support for providing a custom path to a pubspec but there isn't
+/// any current implementation to receive it via the generator itself.
+FutureOr<bool> checkPubspecAndWrapperForFlutterSupport(
+    {Wrapper? wrapper = Wrapper.none, String? providedPubspecPath}) async {
+  if ([Wrapper.flutterw, Wrapper.fvm].contains(wrapper)) {
+    return true;
+  } else {
+    // Use the path provided or default the directory the command was called from.
+    final pubspecPath = providedPubspecPath ??
+        '${Directory.current.path}${Platform.pathSeparator}pubspec.yaml';
+
+    final pubspecFile = File(pubspecPath);
+
+    if (!pubspecFile.existsSync()) {
+      return Future.error('Pubspec doesn\'t exist at path: $pubspecPath');
+    }
+
+    final contents = await pubspecFile.readAsString();
+    if (contents.isEmpty) {
+      return Future.error('Invalid pubspec.yaml');
+    }
+
+    final pubspec = loadYaml(contents) as YamlMap;
+
+    return pubspec.containsKey('dependencies') &&
+        (pubspec.nodes['dependencies'] as YamlMap).containsKey('flutter');
+  }
+}

openapi-generator/lib/src/extensions/type_methods.dart

@@ -1,5 +1,7 @@
 import 'dart:mirrors';
 
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:source_gen/source_gen.dart' show ConstantReader, TypeChecker;
 
@@ -71,3 +73,38 @@ extension TypeMethods on ConstantReader {
     return values[enumIndex];
   }
 }
+
+extension ReadProperty on ConstantReader {
+  T readPropertyOrDefault<T>(String name, T defaultValue) {
+    final v = peek(name);
+    if (v == null) {
+      return defaultValue;
+    }
+
+    // TODO: This may be way too naive
+    if (defaultValue is Map<String, DartObject>) {
+      return v.revive().namedArguments as T;
+    }
+
+    switch (T) {
+      case Map:
+        return v.mapValue as T;
+      case bool:
+        return v.boolValue as T;
+      case int:
+        return v.intValue as T;
+      case List:
+        return v.listValue as T;
+      case double:
+        return v.doubleValue as T;
+      case String:
+        return v.stringValue as T;
+      case Set:
+        return v.setValue as T;
+      case Literal:
+        return v.literalValue as T;
+      default:
+        return defaultValue;
+    }
+  }
+}

openapi-generator/lib/src/gen_on_spec_changes.dart

@@ -6,9 +6,9 @@ import 'dart:io';
 import 'package:yaml/yaml.dart';
 
 // .json
-final jsonRegex = RegExp(r'.*.json$');
+final jsonRegex = RegExp(r'^.*.json$');
 // .yml & .yaml
-final yamlRegex = RegExp(r'.*(.ya?ml)$');
+final yamlRegex = RegExp(r'^.*(.ya?ml)$');
 
 final _supportedRegexes = [jsonRegex, yamlRegex];
 
@@ -21,12 +21,14 @@ final _supportedRegexes = [jsonRegex, yamlRegex];
 /// - yml
 ///
 /// It also throws an error when the specification doesn't exist on disk.
+///
+/// WARNING: THIS DOESN'T VALIDATE THE SPECIFICATION CONTENT
 FutureOr<Map<String, dynamic>> loadSpec(
     {required String specPath, bool isCached = false}) async {
   // If the spec file doesn't match any of the currently supported spec formats
   // reject the request.
   if (!_supportedRegexes.any((fileEnding) => fileEnding.hasMatch(specPath))) {
-    return Future.error('Invalid spec format');
+    return Future.error('Invalid spec file format');
   }
 
   final file = File(specPath);
@@ -210,9 +212,29 @@ List<dynamic> convertYamlListToDartList({required YamlList yamlList}) {
 
 /// Caches the updated [spec] to disk for use in future comparisons.
 ///
-/// Caches the [spec] to the given [outputDirectory]. By default this will be likely
-/// be the .dart_tool or build directory.
+/// Caches the [spec] to the given [outputLocation]. By default this will be likely
+/// be the .dart_tool/openapi-generator-cache.json
 Future<void> cacheSpec({
-  required String outputDirectory,
+  required String outputLocation,
   required Map<String, dynamic> spec,
-}) async {}
+}) async {
+  final outputPath = outputLocation;
+  final outputFile = File(outputPath);
+  if (outputFile.existsSync()) {
+    log('Found cached asset updating');
+  } else {
+    log('No previous openapi-generated cache found. Creating cache');
+  }
+
+  return await outputFile.writeAsString(jsonEncode(spec)).then(
+    (_) => log('Successfully wrote cache.'),
+    onError: (e, st) {
+      log(
+        'Failed to write cache',
+        error: e,
+        stackTrace: st,
+      );
+      return Future.error('Failed to write cache');
+    },
+  );
+}

openapi-generator/lib/src/models/command.dart

@@ -0,0 +1,31 @@
+import 'package:openapi_generator_annotations/openapi_generator_annotations.dart';
+
+/// Creates a representation of a cli request for Flutter or Dart.
+class Command {
+  final String _executable;
+  final List<String> _arguments;
+
+  String get executable => _executable;
+
+  List<String> get arguments => _arguments;
+
+  Command._(this._executable, this._arguments);
+
+  /// Provides an in memory representation of the Dart of Flutter cli command.
+  ///
+  /// If [executable] is the Dart executable or the [wrapper] is [Wrapper.none]
+  /// it provides the raw executable. Otherwise it wraps it in the appropriate
+  /// wrapper, flutterw and fvm respectively.
+  Command({
+    Wrapper wrapper = Wrapper.none,
+    required String executable,
+    required List<String> arguments,
+  }) : this._(
+          executable == 'dart' || wrapper == Wrapper.none
+              ? executable
+              : wrapper == Wrapper.flutterw
+                  ? './flutterw'
+                  : 'fvm',
+          [if (wrapper != Wrapper.none) executable, ...arguments],
+        );
+}