Decoder is now a class.

Author: simphotonics

example/bin/decoder_example.dart

@@ -0,0 +1,95 @@
+import 'package:analyzer/dart/constant/value.dart';
+import 'package:ansi_modifier/ansi_modifier.dart';
+import 'package:build_test/build_test.dart' show resolveSource;
+import 'package:generic_reader/generic_reader.dart';
+
+/// To run this program navigate to the root folder
+/// in your local copy the package `generic_reader` and
+/// use the command:
+///
+/// # dart example/bin/decoder_example.dart
+
+/// Demonstrates how to use [Reader] to read constants.
+class A {
+  const A({required this.id, required this.names, required this.numbers});
+  final int id;
+  final Set<String> names;
+  final List<num> numbers;
+
+  @override
+  String toString() =>
+      'A(id: $id, names: $names, '
+      'numbers: $numbers )';
+}
+
+final a = const A(id: 42, names: {'Andy', 'Eva'}, numbers: [42, 3.14]);
+
+class DecoderForClassA extends Decoder<A> {
+  const DecoderForClassA();
+  @override
+  A read(DartObject obj) {
+    final id = obj.read<int>(fieldName: 'id');
+    final names = obj.readSet<String>(fieldName: 'names');
+    final numbers = obj.readList<num>(fieldName: 'numbers');
+    return A(id: id, names: names, numbers: numbers);
+  }
+}
+
+const decoderForA = DecoderForClassA();
+
+Future<void> main() async {
+  final library = await resolveSource(
+    r'''
+    library example;
+
+    class A {
+      const A({required this.id, required this.names, required this.numbers});
+      final int id;
+      final Set<String> names;
+      final List<num> numbers;
+    }
+
+    class B{
+      const B();
+      final int id = 124;
+      final Map<String, int> score = {'Adam': 4, 'Moira': 7};
+      final isValid = true;
+
+      final a = const A(id: 42, names: {'Andy', 'Eva'}, numbers: [42, 3.14]);
+    }
+
+    ''',
+    (resolver) => resolver.findLibraryByName('example'),
+    //readAllSourcesFromFilesystem: false,
+  );
+
+  /// Reading libraries.
+  print('\nReading library <example>\n');
+
+  final lib = library!;
+
+  final idObj = lib.classes[1].fields[0].computeConstantValue();
+  final id = idObj?.read<int>();
+  print('Reading an ${'int:'.style(Ansi.green)} $id\n');
+
+  final scoreObj = lib.classes[1].fields[1].computeConstantValue();
+  final score = scoreObj?.readMap<String, int>();
+  print(
+    'Reading a ${'Map<String, int>'.style(Ansi.green)}: '
+    '$score ${score.runtimeType}\n',
+  );
+
+  final isValidObj = lib.classes[1].fields[2].computeConstantValue();
+  final isValid = isValidObj?.read<bool>();
+  print(
+    'Reading a ${'bool'.style(Ansi.green)}: $isValid ${isValid.runtimeType}\n',
+  );
+
+  /// Adding a decoder:
+  Reader.addDecoder(decoderForA);
+
+  final aObj = lib.classes[1].fields[3].computeConstantValue();
+  final a = aObj?.read<A>();
+
+  print('Reading a constant with type ${'A'.style(Ansi.green)}: $a');
+}

lib/src/decoder/collection_decoder.dart

@@ -0,0 +1,36 @@
+part of '../reader.dart';
+
+class ListDecoder<T> extends Decoder<List<T>> {
+  const ListDecoder();
+
+  @override
+  List<T> read(DartObject obj) =>
+      switch (obj.toListValue()?.map((item) => item.read<T>())) {
+        Iterable<T> iterable => iterable.toList(),
+        _ => throw readError(obj),
+      };
+}
+
+class SetDecoder<T> extends Decoder<Set<T>> {
+  const SetDecoder({this.prototype = const {}});
+  final Set<T> prototype;
+
+  @override
+  Set<T> read(DartObject obj) =>
+      switch (obj.toSetValue()?.map((item) => item.read<T>())) {
+        Iterable<T> iterable => iterable.toSet(),
+        _ => throw readError(obj),
+      };
+}
+
+class IterableDecoder<T> extends Decoder<Iterable<T>> {
+  const IterableDecoder({this.prototype = const {}});
+  final Set<T> prototype;
+
+  @override
+  Set<T> read(DartObject obj) =>
+      switch (obj.toSetValue()?.map((item) => item.read<T>())) {
+        Iterable<T> iterable => iterable.toSet(),
+        _ => throw readError(obj),
+      };
+}

lib/src/decoder/core_decoder.dart

@@ -0,0 +1,100 @@
+import 'package:analyzer/dart/constant/value.dart' show DartObject;
+
+import '../extension/type_methods.dart';
+import 'decoder.dart';
+
+class BoolDecoder extends Decoder<bool> {
+  const BoolDecoder();
+  @override
+  bool read(DartObject obj) => switch (obj.toBoolValue()) {
+    bool value => value,
+    _ => throw readError(obj),
+  };
+}
+
+const boolDecoder = BoolDecoder();
+
+class IntDecoder extends Decoder<int> {
+  const IntDecoder();
+  @override
+  int read(DartObject obj) => switch (obj.toIntValue()) {
+    int value => value,
+    _ => throw readError(obj),
+  };
+}
+
+const intDecoder = IntDecoder();
+
+class DoubleDecoder extends Decoder<double> {
+  const DoubleDecoder();
+  @override
+  double read(DartObject obj) => switch (obj.toDoubleValue()) {
+    double value => value,
+    _ => throw readError(obj),
+  };
+}
+
+const doubleDecoder = DoubleDecoder();
+
+class NumDecoder extends Decoder<num> {
+  const NumDecoder();
+  @override
+  num read(DartObject obj) {
+    if (obj.isInt) {
+      return intDecoder.read(obj);
+    } else if (obj.isDouble) {
+      return doubleDecoder.read(obj);
+    } else {
+      throw readError(obj);
+    }
+  }
+}
+
+const numDecoder = NumDecoder();
+
+class StringDecoder extends Decoder<String> {
+  const StringDecoder();
+  @override
+  String read(DartObject obj) => switch (obj.toStringValue()) {
+    String value => value,
+    _ => throw readError(obj),
+  };
+}
+
+const stringDecoder = StringDecoder();
+
+class SymbolDecoder extends Decoder<Symbol> {
+  const SymbolDecoder();
+  @override
+  Symbol read(DartObject obj) => switch (obj.toSymbolValue()) {
+    String value => Symbol(value),
+    _ => throw readError(obj),
+  };
+}
+
+const symbolDecoder = SymbolDecoder();
+
+class TypeDecoder extends Decoder<Type> {
+  const TypeDecoder();
+  @override
+  Type read(DartObject obj) => switch (obj.toTypeValue()) {
+    Type type => type,
+    _ => throw readError(obj),
+  };
+}
+
+const typeDecoder = TypeDecoder();
+
+/// A generic enum decoder
+class EnumDecoder<E extends Enum> extends Decoder<E> {
+  const EnumDecoder(this.values);
+
+  /// Use the static enum getter to obtain the values.
+  final List<E> values;
+
+  @override
+  E read(DartObject obj) => switch (obj.getField('index')?.toIntValue()) {
+    int index when index < values.length => values[index],
+    _ => throw readError(obj),
+  };
+}

lib/src/decoder/decoder.dart

@@ -0,0 +1,35 @@
+import 'package:analyzer/dart/constant/value.dart' show DartObject;
+import 'package:exception_templates/exception_templates.dart' show ErrorOf;
+
+import '../type/type_utils.dart';
+
+abstract class Decoder<T> {
+  const Decoder();
+
+  /// Returns `true` if this decoder can read instances of
+  /// [DartObject] representing type [S], and `false` otherwise.
+  bool canDecode<S>() => isSubType<S, T>();
+
+  /// Attempts to create an instance of [T] with information read from
+  /// [obj].
+  ///
+  /// Should throw [ErrorOf] with type argument [Decoder] with type argument
+  /// [T] if an instance of [T] cannot be read from [obj].
+  T read(DartObject obj);
+
+  /// Returns the generic type of the decoder.
+  Type get type => T;
+
+  /// Error thrown if [obj] does not hold a variable of type [T].
+  ErrorOf<Decoder<T>> readError(DartObject obj) {
+    return ErrorOf<Decoder<T>>(
+      message: 'Error reading const <$T> value.',
+      invalidState:
+          'obj holds a variable with static type: '
+          '${obj.type}',
+      expectedState:
+          'The parameter \'obj\' must hold a '
+          'constant with type <$T>.',
+    );
+  }
+}

test/decoder_test.dart

@@ -0,0 +1,13 @@
+import 'package:generic_reader/generic_reader.dart';
+import 'package:test/test.dart';
+
+void main() async {
+  group('numDecoder:', () {
+    test('canDecode<int>()', () {
+      expect(numDecoder.canDecode<int>(), true);
+    });
+    test('canDecode<double>()', () {
+      expect(numDecoder.canDecode<double>(), true);
+    });
+  });
+}