func()

in pkg/notes/notes.go [261:358]
84 lines of code
19 McCabe index (conditional complexity)

func (g *Gatherer) ListReleaseNotes() (*ReleaseNotes, error) {
	// Load map providers
	mapProviders := []MapProvider{}
	for _, initString := range g.options.MapProviderStrings {
		provider, err := NewProviderFromInitString(initString)
		if err != nil {
			return nil, errors.Wrap(err, "while getting release notes map providers")
		}
		mapProviders = append(mapProviders, provider)
	}

	commits, err := g.listCommits(g.options.Branch, g.options.StartSHA, g.options.EndSHA)
	if err != nil {
		return nil, errors.Wrap(err, "listing commits")
	}

	// Get the PRs into a temporary results set
	resultsTemp, err := g.gatherNotes(commits)
	if err != nil {
		return nil, errors.Wrap(err, "gathering notes")
	}

	// Cycle the results and add the complete notes, as well as those that
	// have a map associated with it
	results := []*Result{}
	logrus.Info("Checking PRs for mapped data")
	for _, res := range resultsTemp {
		// If the PR has no release note, check if we have to add it
		if MatchesExcludeFilter(*res.pullRequest.Body) {
			for _, provider := range mapProviders {
				noteMaps, err := provider.GetMapsForPR(res.pullRequest.GetNumber())
				if err != nil {
					return nil, errors.Wrapf(
						err, "checking if a map exists for PR %d", res.pullRequest.GetNumber(),
					)
				}
				if len(noteMaps) != 0 {
					logrus.Infof(
						"Artificially adding pr #%d because a map for it was found",
						res.pullRequest.GetNumber(),
					)
					results = append(results, res)
				} else {
					logrus.Debugf(
						"Skipping PR #%d because it contains no release note",
						res.pullRequest.GetNumber(),
					)
				}
			}
		} else {
			// Append the note as it is
			results = append(results, res)
		}
	}

	dedupeCache := map[string]struct{}{}
	notes := NewReleaseNotes()
	for _, result := range results {
		if g.options.RequiredAuthor != "" {
			if result.commit.GetAuthor().GetLogin() != g.options.RequiredAuthor {
				logrus.Infof(
					"Skipping release note for PR #%d because required author %q does not match with %q",
					result.pullRequest.GetNumber(), g.options.RequiredAuthor, result.commit.GetAuthor().GetLogin(),
				)
				continue
			}
		}

		note, err := g.ReleaseNoteFromCommit(result)
		if err != nil {
			logrus.Errorf(
				"Getting the release note from commit %s (PR #%d): %v",
				result.commit.GetSHA(),
				result.pullRequest.GetNumber(),
				err)
			continue
		}

		// Query our map providers for additional data for the release note
		for _, provider := range mapProviders {
			noteMaps, err := provider.GetMapsForPR(result.pullRequest.GetNumber())
			if err != nil {
				return nil, errors.Wrap(err, "Error while looking up note map")
			}

			for _, noteMap := range noteMaps {
				if err := note.ApplyMap(noteMap, g.options.AddMarkdownLinks); err != nil {
					return nil, errors.Wrapf(err, "applying notemap for PR #%d", result.pullRequest.GetNumber())
				}
			}
		}
		if _, ok := dedupeCache[note.Text]; !ok {
			notes.Set(note.PrNumber, note)
			dedupeCache[note.Text] = struct{}{}
		}
	}
	return notes, nil
}