Config.fromFile constructor

Config.fromFile(File configFile)

Parses and creates config from a file

Implementation

factory Config.fromFile(File configFile) {
  if (!configFile.existsSync()) {
    return throw FileSystemException(
      '${configFile.path} file not found in current directory.',
    );
  }

  YamlMap config = loadYaml(configFile.readAsStringSync());

  Object? permittedLicenses = config['permittedLicenses'];
  Object? rejectedLicenses = config['rejectedLicenses'];
  Object? approvedPackages = config['approvedPackages'];
  Object? copyrightNotice = config['copyrightNotice'];
  Object? packageLicenseOverride = config['packageLicenseOverride'];
  Object? packageSourceOverride = config['packageSourceOverride'];
  Object? omitDisclaimer = config['omitDisclaimer'];
  if (permittedLicenses == null) {
    return throw FormatException('`permittedLicenses` not defined');
  }
  if (permittedLicenses is! List) {
    return throw FormatException(
      '`permittedLicenses` is not defined as a list',
    );
  }
  if (rejectedLicenses != null && rejectedLicenses is! List) {
    return throw FormatException(
      '`rejectedLicenses` is not defined as a list',
    );
  }
  if (omitDisclaimer != null && omitDisclaimer is! List) {
    return throw FormatException(
      '`omitDisclaimer` is not defined as a list',
    );
  }

  List<String> stringRejectLicenses = [];
  List<String> stringOmitDisclaimer = [];
  List<String> stringLicenses =
      permittedLicenses.whereType<String>().toList();
  if (rejectedLicenses != null && rejectedLicenses is List) {
    stringRejectLicenses = rejectedLicenses.whereType<String>().toList();
  }
  if (omitDisclaimer != null && omitDisclaimer is List) {
    stringOmitDisclaimer = omitDisclaimer.whereType<String>().toList();
  }

  Map<String, List<String>> checkedApprovedPackages = {};
  if (approvedPackages != null) {
    if (approvedPackages is! Map) {
      return throw FormatException('`approvedPackages` not defined as a map');
    }
    for (MapEntry<dynamic, dynamic> entry in approvedPackages.entries) {
      Object license = entry.key;
      Object packages = entry.value;
      if (license is! String) {
        return throw FormatException(
          '`approvedPackages` must be keyed by a string license name',
        );
      }
      if (packages is! List) {
        return throw FormatException(
          '`approvedPackages` value must specified as a list',
        );
      }

      List<String> stringApprovedPackages =
          packages.whereType<String>().toList();

      checkedApprovedPackages[license] = stringApprovedPackages;
    }
  }
  Map<String, String> checkedCopyrightNotice =
      _checkStringMap(copyrightNotice, 'copyrightNotice');

  Map<String, String> checkedPackageLicenseOverride =
      _checkStringMap(packageLicenseOverride, 'packageLicenseOverride');

  Map<String, String> checkedPackageSourceOverride =
      _checkStringMap(packageSourceOverride, 'packageSourceOverride');

  return Config._(
    permittedLicenses: stringLicenses,
    approvedPackages: checkedApprovedPackages,
    rejectedLicenses: stringRejectLicenses,
    copyrightNotice: checkedCopyrightNotice,
    packageLicenseOverride: checkedPackageLicenseOverride,
    packageSourceOverride: checkedPackageSourceOverride,
    omitDisclaimer: stringOmitDisclaimer,
  );
}