Line data    Source code

       1              : import 'package:analyzer/dart/element/element.dart';
       2              : import 'package:code_builder/code_builder.dart';
       3              : import 'package:flutter_navigation_generator/src/models/importable_type.dart';
       4              : import 'package:flutter_navigation_generator/src/resolvers/importable_type_resolver.dart';
       5              : import 'package:source_gen/source_gen.dart';
       6              : 
       7            0 : String capitalize(String s) {
       8            0 :   if (s.length < 2) {
       9            0 :     return s.toUpperCase();
      10              :   }
      11            0 :   return s[0].toUpperCase() + s.substring(1);
      12              : }
      13              : 
      14            0 : String toCamelCase(String s) {
      15            0 :   if (s.length < 2) {
      16            0 :     return s.toLowerCase();
      17              :   }
      18            0 :   return s[0].toLowerCase() + s.substring(1);
      19              : }
      20              : 
      21            0 : void throwBoxed(String message) {
      22              :   const pre = 'Injectable Generator ';
      23            0 :   throw ("\n${pre.padRight(72, '-')}\n$message\n${''.padRight(72, '-')} \n");
      24              : }
      25              : 
      26            0 : void throwSourceError(String message) {
      27              :   const pre = 'Injectable Generator ';
      28            0 :   throw ("\n${pre.padRight(72, '-')}\n$message\n${''.padRight(72, '-')} \n");
      29              : }
      30              : 
      31            0 : void throwError(String message, {Element? element}) {
      32            0 :   throw InvalidGenerationSourceError(
      33              :     message,
      34              :     element: element,
      35              :   );
      36              : }
      37              : 
      38            0 : void throwIf(bool condition, String message, {Element? element}) {
      39              :   if (condition) {
      40            0 :     throw InvalidGenerationSourceError(
      41              :       message,
      42              :       element: element,
      43              :     );
      44              :   }
      45              : }
      46              : 
      47            0 : void printBoxed(String message,
      48              :     {String header = '--------------------------'}) {
      49              :   final pre = header;
      50              :   // ignore: avoid_print
      51            0 :   print("$pre\n$message\n${''.padRight(72, '-')} \n");
      52              : }
      53              : 
      54            3 : Reference typeRefer(
      55              :   ImportableType? type, {
      56              :   Uri? targetFile,
      57              :   bool withNullabilitySuffix = true,
      58              :   bool forceNullable = false,
      59              :   bool forceFuture = false,
      60              : }) {
      61              :   final TypeReference typeReference;
      62              :   if (type == null) {
      63            6 :     typeReference = TypeReference((r) => r..symbol = 'void');
      64              :   } else {
      65              :     final relativeImport = targetFile == null
      66            6 :         ? ImportableTypeResolver.resolveAssetImport(type.import)
      67            0 :         : ImportableTypeResolver.relative(type.import, targetFile);
      68            6 :     typeReference = TypeReference((reference) {
      69              :       reference
      70            6 :         ..symbol = type.className
      71            3 :         ..url = relativeImport
      72            3 :         ..isNullable =
      73            3 :             withNullabilitySuffix && (forceNullable || type.isNullable);
      74            6 :       if (type.typeArguments.isNotEmpty) {
      75            0 :         reference.types.addAll(
      76            0 :           type.typeArguments.map((e) => typeRefer(
      77              :                 e,
      78              :                 targetFile: targetFile,
      79              :                 withNullabilitySuffix: withNullabilitySuffix,
      80              :               )),
      81              :         );
      82              :       }
      83              :     });
      84              :   }
      85              :   if (!forceFuture) return typeReference;
      86            0 :   return TypeReference(
      87            0 :     (r) => r
      88            0 :       ..symbol = 'Future'
      89            0 :       ..types.add(typeReference),
      90              :   );
      91              : }
      92              : 
      93              : extension StringExtension on String {
      94            4 :   List<String> get pathSegments => Uri.parse(this).pathSegments.toList();
      95              : 
      96            2 :   List<String> get parametersFromRouteName => pathSegments
      97            3 :       .where((element) => element.startsWith(':'))
      98            3 :       .map((e) => e.substring(1))
      99            1 :       .toList();
     100              : }