parsingHandler static method

Future<Map<String, dynamic>> parsingHandler(List<Parser> allParsers, List<Parser> parsers, dynamic dom)

Implementation

static Future<Map<String, dynamic>> parsingHandler(
  List<Parser> allParsers,
  List<Parser> parsers,
  dynamic dom,
) async {
  //Data only used for operations
  List privateIds = [];
  //Data shown in output
  Map<String, dynamic> publicData = {};

  for (final parser in parsers) {
    String id = parser.id;

    //If parser is private then check if privateData has an object with same ID
    if (parser.isPrivate) {
      if (privateIds.contains(id)) {
        continue;
      }
      //If parser is public then check if publicData has an object with same ID
    } else {
      if (publicData[id] != null) {
        continue;
      }
    }
    var parsedData = await runParser(parser, dom);
    if (parsedData != null) {
      dynamic data = parsedData;
      if (parser.optional != null) {
        //Select nth result
        if (parser.optional!.nth != null && data is List) {
          if (data.length >= (parser.optional!.nth! + 1)) {
            data = data[parser.optional!.nth!];
          }
        }
        //Apply methods
        if (parser.optional!.apply != null) {
          switch (parser.optional!.apply) {
            case ApplyMethod.urldecode:
              data = Uri.decodeFull(data);
              break;
            case ApplyMethod.mapToList:
              if (data is Map) {
                data = data.values.toList();
              }
              break;
            default:
          }
        }
        //Simple replace
        if (parser.optional!.replace != null) {
          if (data is List) {
            List tmpR = [];
            for (final r in data) {
              var tmpD = r;
              parser.optional!.replace!.forEach((key, value) {
                tmpD = tmpD.toString().replaceFirst(key, value);
              });
              tmpR.add(tmpD);
            }
            data = tmpR;
          } else {
            parser.optional!.replace!.forEach((key, value) {
              data = data.toString().replaceFirst(key, value);
            });
          }
        }
        //Regex replace
        if (parser.optional!.regexReplace != null) {
          final re = RegExp(parser.optional!.regexReplace!);
          String replaceWith = "";
          if (parser.optional!.regexReplaceWith != null) {
            replaceWith = parser.optional!.regexReplaceWith!;
          }
          if (data is List) {
            List<String> cleanedData = [];
            for (final l in data) {
              String sanitized = l.toString().replaceAll(re, replaceWith);
              if (sanitized != "") {
                cleanedData.add(sanitized.trim());
              }
            }
            if (cleanedData.isNotEmpty) {
              data = cleanedData;
            }
          } else {
            String? sanitized = data.replaceAll(re, replaceWith);
            if (sanitized != null && sanitized != "") {
              data = sanitized;
            }
          }
        }
        //Regex match
        if (parser.optional!.regex != null) {
          RegExp exp = RegExp(parser.optional!.regex!);
          RegExpMatch? regexed = exp.firstMatch(data);
          if (regexed != null) {
            data = regexed.group(parser.optional!.regexGroup ?? 0);
          }
        }
        //Crop String
        int? cropStart = parser.optional!.cropStart;
        int? cropEnd = parser.optional!.cropEnd;
        if (cropStart != null) {
          if (data is List) {
            if (data.length >= cropStart) {
              data.removeRange(0, cropStart);
            }
          } else if (data is String) {
            if (data.length >= cropStart && cropStart > 0) {
              data = data.substring(cropStart).trim();
            }
          }
        }
        if (cropEnd != null) {
          if (data is List) {
            if (cropEnd <= data.length) {
              data.removeRange(data.length - cropEnd, data.length);
            }
          } else if (data is String) {
            if (data.length >= cropEnd && cropEnd > 0) {
              data = data.substring(0, data.length - cropEnd).trim();
            }
          }
        }
        //Prepend
        if (parser.optional!.prepend != null) {
          if (data is List) {
            List tmpD = [];
            for (final d in data) {
              tmpD.add(parser.optional!.prepend! + d);
            }
            data = tmpD;
          } else {
            data = parser.optional!.prepend! + data;
          }
        }
        //Append
        if (parser.optional!.append != null) {
          data = data + parser.optional!.append!;
        }
        //Match with list
        if (parser.optional!.match != null) {
          for (final m in parser.optional!.match!) {
            if (data.toString().contains(m.toString())) {
              data = true;
              break;
            }
          }
          if (data != true) {
            data = false;
          }
        }
      }
      //Apply optional params end
      if (parser.isPrivate) {
        // privateData.addAll({id: data});
        privateIds.add(id);
      } else {
        publicData.addAll({id: data});
      }
      List<Parser> childParsers = childFinder(id, allParsers);
      if (childParsers.isNotEmpty) {
        if (data is List) {
          //Run child parsers for each data entry
          //Add parent id to public data as empty list
          publicData.addAll({id: []});
          for (final ddd in data) {
            var childrenResults =
                await parsingHandler(allParsers, childParsers, ddd);
            if (childrenResults.isNotEmpty) {
              publicData[id].add(childrenResults);
            }
          }
        } else {
          //Run child parsers for data
          Map<String, dynamic> childResult =
              await parsingHandler(allParsers, childParsers, data);
          if (childResult.isNotEmpty) {
            publicData.addAll(childResult);
          }
        }
      }
    }
  }
  return publicData;
}