LCOV - code coverage report
Current view: top level - path_parser - path_grammar_definition.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 225 225 100.0 %
Date: 2022-02-22 16:00:34 Functions: 0 0 -

          Line data    Source code
       1             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/coordinate_pair.dart';
       2             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/coordinate_pair_sequence.dart';
       3             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/coordinate_sequence.dart';
       4             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/curve_to_coordinate_sequence.dart';
       5             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/elliptical_arc_argument.dart';
       6             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/elliptical_arc_argument_sequence.dart';
       7             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/quadratic_bezier_curve_to_coordinate_sequence.dart';
       8             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/smooth_curve_to_coordinate_sequence.dart';
       9             : import 'package:mrx_icon_font_gen/parser/path/model/command.dart';
      10             : import 'package:mrx_icon_font_gen/parser/path/model/commands/close_path_command.dart';
      11             : import 'package:mrx_icon_font_gen/parser/path/model/commands/curve_to_command.dart';
      12             : import 'package:mrx_icon_font_gen/parser/path/model/commands/elliptical_arc_command.dart';
      13             : import 'package:mrx_icon_font_gen/parser/path/model/commands/horizontal_line_to_command.dart';
      14             : import 'package:mrx_icon_font_gen/parser/path/model/commands/line_to_command.dart';
      15             : import 'package:mrx_icon_font_gen/parser/path/model/commands/move_to_command.dart';
      16             : import 'package:mrx_icon_font_gen/parser/path/model/commands/quadratic_bezier_curve_to_command.dart';
      17             : import 'package:mrx_icon_font_gen/parser/path/model/commands/smooth_curve_to_command.dart';
      18             : import 'package:mrx_icon_font_gen/parser/path/model/commands/smooth_quadratic_bezier_curve_to_command.dart';
      19             : import 'package:mrx_icon_font_gen/parser/path/model/commands/vertical_line_to_command.dart';
      20             : import 'package:mrx_icon_font_gen/util/list_util.dart';
      21             : import 'package:petitparser/petitparser.dart';
      22             : 
      23             : class PathGrammarDefinition extends GrammarDefinition {
      24           1 :   @override
      25           3 :   Parser start() => (ref0(svgPath)).end();
      26             : 
      27           9 :   Parser svgPath() => (((ref0(moveto) & ref0(wsp).star()).plus() &
      28           7 :                   (ref0(drawtoCommand) & ref0(wsp).star()).star())
      29           2 :               .map((value) {
      30           3 :             return value.flatten().whereType<Command>().toList();
      31           1 :           }) |
      32           2 :           string('none').map((value) => null))
      33           1 :       .trim();
      34             : 
      35           1 :   Parser drawtoCommand() =>
      36           3 :       ref0(moveto) |
      37           3 :       ref0(closepath) |
      38           3 :       ref0(lineto) |
      39           3 :       ref0(horizontalLineto) |
      40           3 :       ref0(verticalLineto) |
      41           3 :       ref0(curveto) |
      42           3 :       ref0(smoothCurveto) |
      43           3 :       ref0(quadraticBezierCurveto) |
      44           3 :       ref0(smoothQuadraticBezierCurveto) |
      45           2 :       ref0(ellipticalArc);
      46             : 
      47           5 :   Parser moveto() => ((char('M') | char('m')) &
      48           4 :               ref0(wsp).star() &
      49           2 :               ref0(coordinatePairSequence))
      50           2 :           .map((value) {
      51           1 :         return MoveToCommand(
      52           1 :           command: value[0],
      53           1 :           commandArguments: value[2],
      54             :         );
      55             :       });
      56             : 
      57           6 :   Parser closepath() => (char('Z') | char('z')).map((value) {
      58           1 :         return ClosePathCommand(
      59           1 :           command: value[0],
      60             :         );
      61             :       });
      62             : 
      63           5 :   Parser lineto() => ((char('L') | char('l')) &
      64           4 :               ref0(wsp).star() &
      65           2 :               ref0(coordinatePairSequence))
      66           2 :           .map((value) {
      67           1 :         return LineToCommand(
      68           1 :           command: value[0],
      69           1 :           commandArguments: value[2],
      70             :         );
      71             :       });
      72             : 
      73           1 :   Parser horizontalLineto() =>
      74          10 :       ((char('H') | char('h')) & ref0(wsp).star() & ref0(coordinateSequence))
      75           2 :           .map((value) {
      76           1 :         return HorizontalLineToCommand(
      77           1 :           command: value[0],
      78           1 :           commandArguments: CoordinateSequence(
      79           1 :             coordinates: value[2],
      80             :           ),
      81             :         );
      82             :       });
      83             : 
      84           1 :   Parser verticalLineto() =>
      85          10 :       ((char('V') | char('v')) & ref0(wsp).star() & ref0(coordinateSequence))
      86           2 :           .map((value) {
      87           1 :         return VerticalLineToCommand(
      88           1 :           command: value[0],
      89           1 :           commandArguments: CoordinateSequence(
      90           1 :             coordinates: value[2],
      91             :           ),
      92             :         );
      93             :       });
      94             : 
      95           5 :   Parser curveto() => ((char('C') | char('c')) &
      96           4 :               ref0(wsp).star() &
      97           2 :               ref0(curvetoCoordinateSequence))
      98           2 :           .map((value) {
      99           1 :         return CurveToCommand(
     100           1 :           command: value[0],
     101           1 :           commandArguments: CurveToCoordinateSequence(
     102           1 :             coordinatePairTriplets: value[2],
     103             :           ),
     104             :         );
     105             :       });
     106             : 
     107           1 :   Parser curvetoCoordinateSequence() =>
     108           3 :       (ref0(coordinatePairTriplet) &
     109           4 :               ref0(commaWsp).optional() &
     110           2 :               ref0(curvetoCoordinateSequence))
     111           2 :           .map((value) {
     112           1 :         return <CoordinatePairTriplet>[
     113           1 :               value[0],
     114           1 :             ] +
     115           1 :             value[2];
     116           1 :       }) |
     117           4 :       ref0(coordinatePairTriplet).map((value) {
     118           1 :         return <CoordinatePairTriplet>[value];
     119             :       });
     120             : 
     121           5 :   Parser smoothCurveto() => ((char('S') | char('s')) &
     122           4 :               ref0(wsp).star() &
     123           2 :               ref0(smoothCurvetoCoordinateSequence))
     124           2 :           .map((value) {
     125           1 :         return SmoothCurveToCommand(
     126           1 :           command: value[0],
     127           1 :           commandArguments: SmoothCurveToCoordinateSequence(
     128           1 :             coordinatePairDoubles: value[2],
     129             :           ),
     130             :         );
     131             :       });
     132             : 
     133           1 :   Parser smoothCurvetoCoordinateSequence() =>
     134           3 :       (ref0(coordinatePairDouble) &
     135           4 :               ref0(commaWsp).optional() &
     136           2 :               ref0(smoothCurvetoCoordinateSequence))
     137           2 :           .map((value) {
     138           1 :         return <CoordinatePairDouble>[
     139           1 :               value[0],
     140           1 :             ] +
     141           1 :             value[2];
     142           1 :       }) |
     143           5 :       ref0(coordinatePairDouble).map((value) => <CoordinatePairDouble>[value]);
     144             : 
     145           5 :   Parser quadraticBezierCurveto() => ((char('Q') | char('q')) &
     146           4 :               ref0(wsp).star() &
     147           2 :               ref0(quadraticBezierCurvetoCoordinateSequence))
     148           2 :           .map((value) {
     149           1 :         return QuadraticBezierCurveToCommand(
     150           1 :           command: value[0],
     151           1 :           commandArguments: QuadraticBezierCurveToCoordinateSequence(
     152           1 :             coordinatePairDoubles: value[2],
     153             :           ),
     154             :         );
     155             :       });
     156             : 
     157           1 :   Parser quadraticBezierCurvetoCoordinateSequence() =>
     158           3 :       (ref0(coordinatePairDouble) &
     159           4 :               ref0(commaWsp).optional() &
     160           2 :               ref0(quadraticBezierCurvetoCoordinateSequence))
     161           2 :           .map((value) {
     162           1 :         return <CoordinatePairDouble>[
     163           1 :               value[0],
     164           1 :             ] +
     165           1 :             value[2];
     166           1 :       }) |
     167           5 :       ref0(coordinatePairDouble).map((value) => <CoordinatePairDouble>[value]);
     168             : 
     169           5 :   Parser smoothQuadraticBezierCurveto() => ((char('T') | char('t')) &
     170           4 :               ref0(wsp).star() &
     171           2 :               ref0(coordinatePairSequence))
     172           2 :           .map((value) {
     173           1 :         return SmoothQuadraticBezierCurveToCommand(
     174           1 :           command: value[0],
     175           1 :           commandArguments: value[2],
     176             :         );
     177             :       });
     178             : 
     179           5 :   Parser ellipticalArc() => ((char('A') | char('a')) &
     180           4 :               ref0(wsp).star() &
     181           2 :               ref0(ellipticalArcArgumentSequence))
     182           2 :           .map((value) {
     183           1 :         return EllipticalArcCommand(
     184           1 :           command: value[0],
     185           1 :           commandArguments: EllipticalArcArgumentSequence(
     186           1 :             ellipticalArcArguments: value[2],
     187             :           ),
     188             :         );
     189             :       });
     190             : 
     191           1 :   Parser ellipticalArcArgumentSequence() =>
     192           3 :       (ref0(ellipticalArcArgument) &
     193           4 :               ref0(commaWsp).optional() &
     194           2 :               ref0(ellipticalArcArgumentSequence))
     195           2 :           .map((value) {
     196           1 :         return <EllipticalArcArgument>[
     197           1 :               value[0],
     198           1 :             ] +
     199           1 :             value[2];
     200           1 :       }) |
     201           4 :       ref0(ellipticalArcArgument).map((value) {
     202           1 :         return <EllipticalArcArgument>[value];
     203             :       });
     204             : 
     205           4 :   Parser ellipticalArcArgument() => (ref0(number) &
     206           4 :               ref0(commaWsp).optional() &
     207           3 :               ref0(number) &
     208           4 :               ref0(commaWsp).optional() &
     209           3 :               ref0(number) &
     210           4 :               ref0(commaWsp).optional() &
     211           3 :               ref0(flag) &
     212           4 :               ref0(commaWsp).optional() &
     213           3 :               ref0(flag) &
     214           4 :               ref0(commaWsp).optional() &
     215           2 :               ref0(coordinatePair))
     216           2 :           .map((value) {
     217           1 :         return EllipticalArcArgument(
     218           1 :           rx: value[0],
     219           1 :           ry: value[2],
     220           1 :           xAxisRotation: value[4],
     221           1 :           largeArcFlag: value[6],
     222           1 :           sweepFlag: value[8],
     223           2 :           x: value[10].x,
     224           2 :           y: value[10].y,
     225             :         );
     226             :       });
     227             : 
     228           1 :   Parser coordinatePairDouble() =>
     229           9 :       (ref0(coordinatePair) & ref0(commaWsp).optional() & ref0(coordinatePair))
     230           2 :           .map((value) {
     231           1 :         return CoordinatePairDouble(
     232           1 :           coordinatePairs: <CoordinatePair>[
     233           1 :             value[0],
     234           1 :             value[2],
     235             :           ],
     236             :         );
     237             :       });
     238             : 
     239           4 :   Parser coordinatePairTriplet() => (ref0(coordinatePair) &
     240           4 :               ref0(commaWsp).optional() &
     241           3 :               ref0(coordinatePair) &
     242           4 :               ref0(commaWsp).optional() &
     243           2 :               ref0(coordinatePair))
     244           2 :           .map((value) {
     245           1 :         return CoordinatePairTriplet(
     246           1 :           coordinatePairs: <CoordinatePair>[
     247           1 :             value[0],
     248           1 :             value[2],
     249           1 :             value[4],
     250             :           ],
     251             :         );
     252             :       });
     253             : 
     254           1 :   Parser coordinatePairSequence() =>
     255           3 :       (ref0(coordinatePair) &
     256           4 :               ref0(commaWsp).optional() &
     257           2 :               ref0(coordinatePairSequence))
     258           2 :           .map((value) {
     259           1 :         return CoordinatePairSequence(
     260           1 :           coordinatePairs: <CoordinatePair>[
     261           1 :                 value[0],
     262           1 :               ] +
     263           2 :               value[2].coordinatePairs,
     264             :         );
     265           1 :       }) |
     266           4 :       ref0(coordinatePair).map((value) {
     267           1 :         return CoordinatePairSequence(
     268           1 :           coordinatePairs: <CoordinatePair>[value],
     269             :         );
     270             :       });
     271             : 
     272           1 :   Parser coordinateSequence() =>
     273           9 :       (ref0(coordinate) & ref0(commaWsp).optional() & ref0(coordinateSequence))
     274           2 :           .map((value) {
     275           1 :         return <double>[
     276           1 :               value[0],
     277           1 :             ] +
     278           1 :             value[2];
     279           1 :       }) |
     280           4 :       ref0(coordinate).map((value) {
     281           1 :         return <double>[value];
     282             :       });
     283             : 
     284           1 :   Parser coordinatePair() =>
     285           9 :       (ref0(coordinate) & ref0(commaWsp).optional() & ref0(coordinate))
     286           2 :           .map((value) {
     287           1 :         return CoordinatePair(
     288           1 :           x: value[0],
     289           1 :           y: value[2],
     290             :         );
     291             :       });
     292             : 
     293           3 :   Parser coordinate() => ref0(number);
     294             : 
     295           4 :   Parser sign() => char('+') | char('-');
     296             : 
     297           5 :   Parser number() => (ref0(sign).optional() &
     298           5 :           ((char('.') & digit().plus()) |
     299           8 :               (digit().plus() & char('.') & digit().star()) |
     300           3 :               digit().plus()) &
     301          10 :           ((char('E') | char('e')) & ref0(sign).optional() & digit().plus())
     302           1 :               .optional())
     303           1 :       .flatten()
     304           1 :       .map(double.parse);
     305             : 
     306           7 :   Parser flag() => (char('0') | char('1')).map((value) => int.parse(value));
     307             : 
     308           1 :   Parser commaWsp() =>
     309          11 :       ((ref0(wsp).plus() & char(',').optional() & ref0(wsp).star()) |
     310           5 :               (char(',') & ref0(wsp).star()))
     311           2 :           .map((_) => null);
     312             : 
     313           4 :   Parser wsp() => (char(String.fromCharCode(0x9)) |
     314           3 :           char(String.fromCharCode(0x20)) |
     315           3 :           char(String.fromCharCode(0xA)) |
     316           3 :           char(String.fromCharCode(0xC)) |
     317           2 :           char(String.fromCharCode(0xD)))
     318           2 :       .map((_) => null);
     319             : }

Generated by: LCOV version 1.15