Extract logic out of moor generator in some smaller files

moor_generator/lib/src/moor_generator.dart

@@ -1,15 +1,12 @@
 import 'package:moor/moor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:build/build.dart';
-import 'package:moor_generator/src/model/specified_database.dart';
+import 'package:moor_generator/src/state/errors.dart';
 import 'package:moor_generator/src/state/generator_state.dart';
 import 'package:moor_generator/src/state/options.dart';
 import 'package:moor_generator/src/writer/database_writer.dart';
 import 'package:source_gen/source_gen.dart';
 
-import 'model/sql_query.dart';
-import 'parser/sql/sql_parser.dart';
-
 class MoorGenerator extends GeneratorForAnnotation<UseMoor> {
   final MoorOptions options;
   MoorGenerator(this.options);
@@ -20,24 +17,17 @@ class MoorGenerator extends GeneratorForAnnotation<UseMoor> {
     final state = useState(() => GeneratorState(options));
     final session = state.startSession(buildStep);
 
-    final tableTypes =
-        annotation.peek('tables').listValue.map((obj) => obj.toTypeValue());
-    final daoTypes = annotation
-        .peek('daos')
-        .listValue
-        .map((obj) => obj.toTypeValue())
-        .toList();
-    final queries = annotation.peek('queries')?.mapValue ?? {};
-
-    final tablesForThisDb = await session.parseTables(tableTypes, element);
-    var resolvedQueries = <SqlQuery>[];
-
-    if (queries.isNotEmpty) {
-      final parser = SqlParser(session, tablesForThisDb, queries)..parse();
-
-      resolvedQueries = parser.foundQueries;
+    if (element is! ClassElement) {
+      session.errors.add(MoorError(
+        critical: true,
+        message: 'This annotation can only be used on classes',
+        affectedElement: element,
+      ));
     }
 
+    final database =
+        await session.parseDatabase(element as ClassElement, annotation);
+
     if (session.errors.errors.isNotEmpty) {
       print('Warning: There were some errors while running '
           'moor_generator on ${buildStep.inputId.path}:');
@@ -52,15 +42,12 @@ class MoorGenerator extends GeneratorForAnnotation<UseMoor> {
       }
     }
 
-    if (tablesForThisDb.isEmpty) return '';
-
-    final specifiedDb = SpecifiedDatabase(
-        element as ClassElement, tablesForThisDb, daoTypes, resolvedQueries);
+    if (database.tables.isEmpty) return '';
 
     final buffer = StringBuffer()
       ..write('// ignore_for_file: unnecessary_brace_in_string_interps\n');
 
-    DatabaseWriter(specifiedDb, options).write(buffer);
+    DatabaseWriter(database, options).write(buffer);
 
     return buffer.toString();
   }

moor_generator/lib/src/parser/use_moor_parser.dart

@@ -1,4 +1,5 @@
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:moor_generator/src/model/specified_database.dart';
 import 'package:moor_generator/src/state/session.dart';
 import 'package:source_gen/source_gen.dart';
@@ -11,8 +12,25 @@ class UseMoorParser {
   /// If [element] has a `@UseMoor` annotation, parses the database model
   /// declared by that class and the referenced tables.
   Future<SpecifiedDatabase> parseDatabase(
-      ClassElement element, ConstantReader annotation) {
+      ClassElement element, ConstantReader annotation) async {
+    // the types declared in UseMoor.tables
     final tableTypes =
         annotation.peek('tables').listValue.map((obj) => obj.toTypeValue());
+    final queryStrings = annotation.peek('queries')?.mapValue ?? {};
+
+    final parsedTables = await session.parseTables(tableTypes, element);
+    final parsedQueries =
+        await session.parseQueries(queryStrings, parsedTables);
+    final daoTypes = _readDaoTypes(annotation);
+
+    return SpecifiedDatabase(element, parsedTables, daoTypes, parsedQueries);
+  }
+
+  List<DartType> _readDaoTypes(ConstantReader annotation) {
+    return annotation
+        .peek('daos')
+        .listValue
+        .map((obj) => obj.toTypeValue())
+        .toList();
   }
 }

moor_generator/lib/src/state/session.dart

@@ -1,12 +1,18 @@
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:build/build.dart';
 import 'package:moor_generator/src/model/specified_column.dart';
+import 'package:moor_generator/src/model/specified_database.dart';
 import 'package:moor_generator/src/model/specified_table.dart';
+import 'package:moor_generator/src/model/sql_query.dart';
 import 'package:moor_generator/src/parser/column_parser.dart';
+import 'package:moor_generator/src/parser/sql/sql_parser.dart';
 import 'package:moor_generator/src/parser/table_parser.dart';
+import 'package:moor_generator/src/parser/use_moor_parser.dart';
+import 'package:source_gen/source_gen.dart';
 
 import 'errors.dart';
 import 'generator_state.dart';
@@ -35,6 +41,14 @@ class GeneratorSession {
     return resolvedLibrary.getElementDeclaration(element);
   }
 
+  /// Parses a [SpecifiedDatabase] from the [ClassElement] which was annotated
+  /// with `@UseMoor` and the [annotation] reader that reads the `@UseMoor`
+  /// annotation.
+  Future<SpecifiedDatabase> parseDatabase(
+      ClassElement element, ConstantReader annotation) {
+    return UseMoorParser(this).parseDatabase(element, annotation);
+  }
+
   /// Resolves a [SpecifiedTable] for the class of each [DartType] in [types].
   /// The [initializedBy] element should be the piece of code that caused the
   /// parsing (e.g. the database class that is annotated with `@UseMoor`). This
@@ -55,7 +69,20 @@ class GeneratorSession {
     }));
   }
 
+  /// Parses a column from a getter [e] declared inside a table class and its
+  /// resolved AST node [m].
   Future<SpecifiedColumn> parseColumn(MethodDeclaration m, Element e) {
     return Future.value(_columnParser.parse(m, e));
   }
+
+  Future<List<SqlQuery>> parseQueries(
+      Map<DartObject, DartObject> fromAnnotation,
+      List<SpecifiedTable> availableTables) {
+    // no queries declared, so there is no point in starting a sql engine
+    if (fromAnnotation.isEmpty) return Future.value([]);
+
+    final parser = SqlParser(this, availableTables, fromAnnotation)..parse();
+
+    return Future.value(parser.foundQueries);
+  }
 }