VersionCommandConfigs.fromYaml constructor

VersionCommandConfigs.fromYaml(Map<Object?, Object?> yaml, { required String workspacePath, bool repositoryIsConfigured = false, })

Implementation

factory VersionCommandConfigs.fromYaml(
  Map<Object?, Object?> yaml, {
  required String workspacePath,
  bool repositoryIsConfigured = false,
}) {
  final branch = assertKeyIsA<String?>(
    key: 'branch',
    map: yaml,
    path: 'command/version',
  );
  final message = assertKeyIsA<String?>(
    key: 'message',
    map: yaml,
    path: 'command/version',
  );
  final includeScopes = assertKeyIsA<bool?>(
    key: 'includeScopes',
    map: yaml,
    path: 'command/version',
  );
  final includeCommitId = assertKeyIsA<bool?>(
    key: 'includeCommitId',
    map: yaml,
    path: 'command/version',
  );
  final linkToCommits = assertKeyIsA<bool?>(
    key: 'linkToCommits',
    map: yaml,
    path: 'command/version',
  );
  final updateGitTagRefs = assertKeyIsA<bool?>(
    key: 'updateGitTagRefs',
    map: yaml,
    path: 'command/version',
  );
  final releaseUrl = assertKeyIsA<bool?>(
    key: 'releaseUrl',
    map: yaml,
    path: 'command/version',
  );

  final workspaceChangelog = assertKeyIsA<bool?>(
    key: 'workspaceChangelog',
    map: yaml,
    path: 'command/version',
  );

  final aggregateChangelogs = <AggregateChangelogConfig>[];
  if (workspaceChangelog ?? true) {
    aggregateChangelogs.add(AggregateChangelogConfig.workspace());
  }

  final changelogsYaml = assertKeyIsA<List<Object?>?>(
    key: 'changelogs',
    map: yaml,
    path: 'command/version',
  );

  if (changelogsYaml != null) {
    for (var i = 0; i < changelogsYaml.length; i++) {
      final entry = changelogsYaml[i]! as Map<Object?, Object?>;

      final path = assertKeyIsA<String>(
        map: entry,
        path: 'command/version/changelogs[$i]',
        key: 'path',
      );

      final packageFiltersMap = assertKeyIsA<Map<Object?, Object?>>(
        map: entry,
        key: 'packageFilters',
        path: 'command/version/changelogs[$i]',
      );
      final packageFilters = PackageFilters.fromYaml(
        packageFiltersMap,
        path: 'command/version/changelogs[$i]',
        workspacePath: workspacePath,
      );

      final description = assertKeyIsA<String?>(
        map: entry,
        path: 'command/version/changelogs[$i]',
        key: 'description',
      );
      final changelogConfig = AggregateChangelogConfig(
        path: path,
        packageFilters: packageFilters,
        description: description,
      );

      aggregateChangelogs.add(changelogConfig);
    }
  }

  final fetchTags = assertKeyIsA<bool?>(
    key: 'fetchTags',
    map: yaml,
    path: 'command/version',
  );

  final hooksMap = assertKeyIsA<Map<Object?, Object?>?>(
    key: 'hooks',
    map: yaml,
    path: 'command/version',
  );

  final hooks = hooksMap != null
      ? VersionLifecycleHooks.fromYaml(
          hooksMap,
          workspacePath: workspacePath,
        )
      : VersionLifecycleHooks.empty;

  final changelogCommitBodiesEntry = assertKeyIsA<Map<Object?, Object?>?>(
        key: 'changelogCommitBodies',
        map: yaml,
        path: 'command/version',
      ) ??
      const {};

  final includeCommitBodies = assertKeyIsA<bool?>(
    key: 'include',
    map: changelogCommitBodiesEntry,
    path: 'command/version/changelogCommitBodies',
  );

  final bodiesOnlyBreaking = assertKeyIsA<bool?>(
    key: 'onlyBreaking',
    map: changelogCommitBodiesEntry,
    path: 'command/version/changelogCommitBodies',
  );

  return VersionCommandConfigs(
    branch: branch,
    message: message,
    includeScopes: includeScopes ?? true,
    includeCommitId: includeCommitId ?? false,
    includeCommitBody: includeCommitBodies ?? false,
    commitBodyOnlyBreaking: bodiesOnlyBreaking ?? true,
    linkToCommits: linkToCommits ?? repositoryIsConfigured,
    updateGitTagRefs: updateGitTagRefs ?? false,
    releaseUrl: releaseUrl ?? false,
    aggregateChangelogs: aggregateChangelogs,
    fetchTags: fetchTags ?? true,
    hooks: hooks,
  );
}