managed simple conversions

Author: KernelPanic92

generator/lib/src/dartstruct_generator.dart

@@ -1,5 +1,4 @@
 import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type_system.dart';
 import 'package:build/build.dart';
 import 'package:build/src/builder/build_step.dart';
 import 'package:code_builder/code_builder.dart';
@@ -191,11 +190,15 @@ class DartStructGenerator extends GeneratorForAnnotation<Mapper> {
     }
 
 
-    if (mapper.returnType != outputField.type && _conversions.canConvert(mapper.returnType, outputField.type)) {
+    if (_conversions.canConvert(mapper.returnType, outputField.type)) {
       mapper = _conversions.convert(mapper.returnType, outputField.type, mapper);
       return mapper.expression;
     }
 
+    if (mapper.returnType != outputField.type) {
+      return null;
+    }
+
     return mapper.expression;
 
   }

generator/lib/src/mappers/conversions/bool_to_num_mapper.dart

@@ -0,0 +1,39 @@
+import 'package:analyzer/dart/element/type.dart';
+import 'package:code_builder/code_builder.dart';
+import 'package:code_builder/src/specs/expression.dart';
+import 'package:dartstruct_generator/src/mappers/mappers.dart';
+
+class BoolToNumMapper implements MapperAdapter {
+
+  final MapperAdapter _mapper;
+  final DartType _numType;
+
+  BoolToNumMapper(this._mapper, this._numType);
+
+  @override
+  Expression get expression {
+
+    final mapperExpression = _mapper.expression;
+
+    return _nullableBoolToNum(mapperExpression);
+
+  }
+
+  Expression _nullableBoolToNum(Expression variable) {
+
+    final nullValue = refer('null');
+    return variable.equalTo(nullValue).conditional(nullValue, _boolToNum(variable));
+
+  }
+
+  Expression _boolToNum(Expression variable) {
+
+    final trueValue = refer('true');
+    return variable.equalTo(trueValue).conditional(refer('1'), refer('0'));
+
+  }
+
+  @override
+  DartType get returnType => _numType;
+
+}

generator/lib/src/mappers/conversions/conversions.dart

@@ -2,11 +2,13 @@ import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/dart/element/type_provider.dart';
+import 'package:dartstruct_generator/src/mappers/conversions/bool_to_num_mapper.dart';
 import 'package:dartstruct_generator/src/mappers/conversions/primitive_to_string_mapper.dart';
+import 'package:dartstruct_generator/src/mappers/conversions/string_to_bool_mapper.dart';
 import 'package:dartstruct_generator/src/mappers/conversions/string_to_num_mapper.dart';
 import 'package:dartstruct_generator/src/mappers/mappers.dart';
 import 'package:equatable/equatable.dart';
+import 'num_to_bool_mapper.dart';
 import 'num_to_num_mapper.dart';
 
 
@@ -22,26 +24,35 @@ class Conversions {
     DartType numType = dartCoreLibrary.getType('num').thisType;
     DartType stringType = dartCoreLibrary.getType('String').thisType;
 
-
     // to string
     _addConvertion(intType, stringType, (parent) => PrimitiveToStringMapper(parent, stringType));
     _addConvertion(doubleType, stringType, (parent) => PrimitiveToStringMapper(parent, stringType));
     _addConvertion(boolType, stringType, (parent) => PrimitiveToStringMapper(parent, stringType));
+    _addConvertion(numType, stringType, (parent) => PrimitiveToStringMapper(parent, stringType));
 
     // to int
     _addConvertion(numType, intType, (parent) => NumToNumMapper(parent, intType));
     _addConvertion(doubleType, intType, (parent) => NumToNumMapper(parent, intType));
     _addConvertion(stringType, intType, (parent) => StringToNumMapper(parent, intType));
+    _addConvertion(boolType, intType, (parent) => BoolToNumMapper(parent, intType));
 
     // to double
     _addConvertion(numType, doubleType, (parent) => NumToNumMapper(parent, doubleType));
     _addConvertion(intType, doubleType, (parent) => NumToNumMapper(parent, doubleType));
     _addConvertion(stringType, doubleType, (parent) => StringToNumMapper(parent, doubleType));
+    _addConvertion(boolType, doubleType, (parent) => BoolToNumMapper(parent, doubleType));
 
     // to num
     _addConvertion(intType, numType, (parent) => NumToNumMapper(parent, numType));
     _addConvertion(doubleType, numType, (parent) => NumToNumMapper(parent, numType));
     _addConvertion(stringType, numType, (parent) => StringToNumMapper(parent, numType));
+    _addConvertion(boolType, numType, (parent) => BoolToNumMapper(parent, numType));
+
+     // to bool
+    _addConvertion(intType, boolType, (parent) => NumToBoolMapper(parent, boolType));
+    _addConvertion(doubleType, boolType, (parent) => NumToBoolMapper(parent, numType));
+    _addConvertion(numType, boolType, (parent) => NumToBoolMapper(parent, numType));
+    _addConvertion(stringType, boolType, (parent) => StringToBoolMapper(parent, numType));
 
   }
 

generator/lib/src/mappers/conversions/num_to_bool_mapper.dart

@@ -0,0 +1,38 @@
+import 'package:analyzer/dart/element/type.dart';
+import 'package:code_builder/code_builder.dart';
+import 'package:code_builder/src/specs/expression.dart';
+import 'package:dartstruct_generator/src/mappers/mappers.dart';
+
+class NumToBoolMapper implements MapperAdapter {
+
+  final MapperAdapter _mapper;
+  final DartType _boolType;
+
+  NumToBoolMapper(this._mapper, this._boolType);
+
+  @override
+  Expression get expression {
+
+    final mapperExpression = _mapper.expression;
+
+    return _nullableNumToBool(mapperExpression);
+
+  }
+
+  Expression _nullableNumToBool(Expression variable) {
+
+    final nullValue = refer('null');
+    return variable.equalTo(nullValue).conditional(nullValue, _numToBool(variable));
+
+  }
+
+  Expression _numToBool(Expression variable) {
+
+    return variable.greaterOrEqualTo(refer('1'));
+
+  }
+
+  @override
+  DartType get returnType => _boolType;
+
+}

generator/lib/src/mappers/conversions/string_to_bool_mapper.dart

@@ -0,0 +1,32 @@
+import 'package:analyzer/dart/element/type.dart';
+import 'package:code_builder/code_builder.dart';
+import 'package:code_builder/src/specs/expression.dart';
+import 'package:dartstruct_generator/src/mappers/mappers.dart';
+
+class StringToBoolMapper implements MapperAdapter {
+
+  final MapperAdapter _mapper;
+  final DartType _numType;
+
+  StringToBoolMapper(this._mapper, this._numType);
+
+  @override
+  Expression get expression {
+
+    final mapperExpression = _mapper.expression;
+
+    return _nullableStringToBoolExpression(mapperExpression);
+
+  }
+
+  Expression _nullableStringToBoolExpression(Expression variable) {
+
+    final nullValue = refer('null');
+    return variable.equalTo(nullValue).conditional(nullValue, variable.nullSafeProperty('toLowerCase').call([]).equalTo(refer('\'true\'')));
+
+  }
+
+  @override
+  DartType get returnType => _numType;
+
+}

generator/lib/src/mappers/conversions/string_to_num_mapper.dart

@@ -16,24 +16,32 @@ class StringToNumMapper implements MapperAdapter {
     final mapperExpression = _mapper.expression;
 
     if (_numType.isDartCoreInt) {
-      return _parseExpression(mapperExpression, 'int');
+      return _nullableParseExpression(mapperExpression, 'int');
     }
 
     if (_numType.isDartCoreDouble) {
-      return _parseExpression(mapperExpression, 'double');
+      return _nullableParseExpression(mapperExpression, 'double');
     }
 
     if (_numType.isDartCoreNum) {
-      return _parseExpression(mapperExpression, 'num');
+      return _nullableParseExpression(mapperExpression, 'num');
     }
 
     return _mapper.expression;
 
   }
 
-  Expression _parseExpression(Expression variable, String parseTo) {
+  Expression _nullableParseExpression(Expression variable, String parseTo) {
+
     final nullValue = refer('null');
-    return variable.equalTo(nullValue).conditional(nullValue, refer(parseTo).property('parse').call([variable]));
+    return variable.equalTo(nullValue).conditional(nullValue, _parseExpression(variable, parseTo));
+
+  }
+
+  Expression _parseExpression(Expression variable, String parseTo) {
+
+    return refer(parseTo).property('parse').call([variable]);
+
   }
 
   @override

integration_tests/test/bool_mapper/bool_mapper.dart

@@ -0,0 +1,51 @@
+
+
+import 'package:dartstruct/dartstruct.dart';
+
+part 'bool_mapper.g.dart';
+
+class Model {
+  int trueInteger$;
+  int falseInteger$;
+  int nullInteger$;
+  String trueString$;
+  String falseString$;
+  String nullString$;
+  num trueNumber$;
+  num falseNumber$;
+  num nullNumber$;
+  double trueDouble$;
+  double falseDouble$;
+  double nullDouble$;
+  bool true$;
+  bool false$;
+  bool nullBool$;
+}
+
+class Dto {
+  bool trueInteger$;
+  bool falseInteger$;
+  bool nullInteger$;
+  bool trueString$;
+  bool falseString$;
+  bool nullString$;
+  bool trueNumber$;
+  bool falseNumber$;
+  bool nullNumber$;
+  bool trueDouble$;
+  bool falseDouble$;
+  bool nullDouble$;
+  bool true$;
+  bool false$;
+  bool nullBool$;
+}
+
+
+@Mapper()
+abstract class BoolMapper {
+
+  static BoolMapper get INSTANCE => BoolMapperImpl();
+
+  Dto modelToDto(Model model);
+
+}

integration_tests/test/bool_mapper/bool_mapping_test.dart

@@ -0,0 +1,109 @@
+
+import 'package:test/test.dart';
+
+import 'bool_mapper.dart';
+
+
+
+
+void main() {
+  group('Bool Mapper', () {
+
+    final model = Model()
+      ..trueString$ = 'true'
+      ..falseString$ = 'string'
+      ..nullString$ = null
+      ..trueDouble$ = 1.1
+      ..falseDouble$ = 0
+      ..nullDouble$ = null
+      ..trueInteger$ = 100
+      ..falseInteger$ = 0
+      ..trueNumber$ = 1
+      ..falseNumber$ = 0
+      ..nullNumber$ = null
+      ..true$ = true
+      ..false$ = false
+      ..nullBool$ = null;
+
+
+    test('Should be instantiated', () {
+      expect(BoolMapper.INSTANCE, isNotNull);
+    });
+
+    test('Should assign field when input is number', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.trueNumber$, equals(true));
+      expect(actual.falseNumber$, equals(false));
+
+    });
+
+     test('Should assign field when input is null number', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.nullNumber$, equals(null));
+
+    });
+
+    test('Should assign field when input is integer', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.trueInteger$, equals(true));
+      expect(actual.falseInteger$, equals(false));
+
+    });
+
+     test('Should assign field when input is null integer', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.nullInteger$, equals(null));
+
+    });
+
+    test('Should assign field when input is double', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.trueDouble$, equals(true));
+      expect(actual.falseDouble$, equals(false));
+
+    });
+
+     test('Should assign field when input is null double', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.nullDouble$, equals(null));
+
+    });
+
+    test('Should assign field when input is string', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.trueString$, equals(true));
+      expect(actual.falseString$, equals(false));
+
+    });
+
+    test('Should assign field when input is null string', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.nullString$, equals(null));
+
+    });
+
+     test('Should assign field when input is bool', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.true$, equals(true));
+      expect(actual.false$, equals(false));
+
+    });
+
+     test('Should assign field when input is null bool', () {
+
+      final actual = BoolMapper.INSTANCE.modelToDto(model);
+      expect(actual.nullBool$, equals(null));
+
+    });
+
+  });
+}